OpenDDS  Snapshot(2021/12/03-20:38)
Classes | Enumerations | Functions | Variables
OpenDDS::STUN Namespace Reference

Classes

struct  Attribute
 
struct  AttributeHolder
 
struct  ConstAttributeHolder
 
struct  Message
 
class  Participant
 
class  Sender
 
struct  TransactionId
 

Enumerations

enum  Class { REQUEST = 0, INDICATION = 1, SUCCESS_RESPONSE = 2, ERROR_RESPONSE = 3 }
 
enum  Method { BINDING = 0x001 }
 
enum  Family { IPv4 = 0x01, IPv6 = 0x02 }
 
enum  AttributeType {
  MAPPED_ADDRESS = 0x0001, USERNAME = 0x0006, MESSAGE_INTEGRITY = 0x0008, ERROR_CODE = 0x0009,
  UNKNOWN_ATTRIBUTES = 0x000A, XOR_MAPPED_ADDRESS = 0x0020, PRIORITY = 0x0024, USE_CANDIDATE = 0x0025,
  FINGERPRINT = 0x8028, ICE_CONTROLLED = 0x8029, ICE_CONTROLLING = 0x802A, GUID_PREFIX = 0xD000,
  LAST_ATTRIBUTE = 0xFFFF
}
 

Functions

Attribute make_mapped_address (const ACE_INET_Addr &addr)
 
Attribute make_username (const std::string &username)
 
Attribute make_message_integrity ()
 
Attribute make_error_code (ACE_UINT16 code, const std::string &reason)
 
Attribute make_unknown_attributes (const std::vector< AttributeType > &unknown_attributes)
 
Attribute make_xor_mapped_address (const ACE_INET_Addr &addr)
 
Attribute make_priority (ACE_UINT32 priority)
 
Attribute make_use_candidate ()
 
Attribute make_fingerprint ()
 
Attribute make_ice_controlling (ACE_UINT64 ice_tie_breaker)
 
Attribute make_ice_controlled (ACE_UINT64 ice_tie_breaker)
 
OpenDDS_Rtps_Export Attribute make_guid_prefix (const DCPS::GuidPrefix_t &guid_prefix)
 
Attribute make_unknown_attribute (ACE_UINT16 type, ACE_UINT16 length)
 
bool operator>> (DCPS::Serializer &serializer, AttributeHolder &holder)
 
bool operator<< (DCPS::Serializer &serializer, ConstAttributeHolder &holder)
 
bool operator>> (DCPS::Serializer &serializer, Message &message)
 
bool operator<< (DCPS::Serializer &serializer, const Message &message)
 
const DCPS::Encoding encoding (DCPS::Encoding::KIND_UNALIGNED_CDR, DCPS::ENDIAN_BIG)
 

Variables

const ACE_UINT32 MAGIC_COOKIE = 0x2112A442
 
const size_t HEADER_SIZE = 20
 
const ACE_UINT16 BAD_REQUEST = 400
 
const ACE_UINT16 UNAUTHORIZED = 401
 
const ACE_UINT16 UNKNOWN_ATTRIBUTE = 420
 

Enumeration Type Documentation

◆ AttributeType

enum OpenDDS::STUN::AttributeType
Enumerator
MAPPED_ADDRESS 
USERNAME 
MESSAGE_INTEGRITY 
ERROR_CODE 
UNKNOWN_ATTRIBUTES 
XOR_MAPPED_ADDRESS 
PRIORITY 
USE_CANDIDATE 
FINGERPRINT 
ICE_CONTROLLED 
ICE_CONTROLLING 
GUID_PREFIX 
LAST_ATTRIBUTE 

Definition at line 55 of file Stun.h.

55  {
56  MAPPED_ADDRESS = 0x0001,
57  USERNAME = 0x0006,
58  MESSAGE_INTEGRITY = 0x0008,
59  ERROR_CODE = 0x0009,
60  UNKNOWN_ATTRIBUTES = 0x000A,
61  // REALM = 0x0014,
62  // NONCE = 0x0015,
63  XOR_MAPPED_ADDRESS = 0x0020,
64  PRIORITY = 0x0024,
65  USE_CANDIDATE = 0x0025,
66 
67  // SOFTWARE = 0x8022,
68  // ALTERNATE_SERVER = 0x8023,
69  FINGERPRINT = 0x8028,
70  ICE_CONTROLLED = 0x8029,
71  ICE_CONTROLLING = 0x802A,
72 
73  GUID_PREFIX = 0xD000,
74 
75  LAST_ATTRIBUTE = 0xFFFF
76 };

◆ Class

enum OpenDDS::STUN::Class
Enumerator
REQUEST 
INDICATION 
SUCCESS_RESPONSE 
ERROR_RESPONSE 

Definition at line 32 of file Stun.h.

32  {
33  REQUEST = 0,
34  INDICATION = 1,
35  SUCCESS_RESPONSE = 2,
36  ERROR_RESPONSE = 3
37 };

◆ Family

enum OpenDDS::STUN::Family
Enumerator
IPv4 
IPv6 

Definition at line 43 of file Stun.h.

43  {
44  IPv4 = 0x01,
45  IPv6 = 0x02
46 };

◆ Method

enum OpenDDS::STUN::Method
Enumerator
BINDING 

Definition at line 39 of file Stun.h.

39  {
40  BINDING = 0x001
41 };

Function Documentation

◆ encoding()

const DCPS::Encoding OpenDDS::STUN::encoding ( DCPS::Encoding::KIND_UNALIGNED_CDR  ,
DCPS::ENDIAN_BIG   
)

Referenced by OpenDDS::DCPS::DataSampleHeader::add_cfentries(), OpenDDS::DCPS::TypeSupportImpl::add_types(), OpenDDS::DCPS::Serializer::align_cont_r(), OpenDDS::DCPS::Serializer::align_cont_w(), OpenDDS::DCPS::Serializer::align_r(), OpenDDS::DCPS::Serializer::align_w(), OpenDDS::DCPS::Serializer::alignment(), OpenDDS::DCPS::DataWriterImpl::association_complete_i(), OpenDDS::DCPS::RtpsUdpDataLink::bundle_and_send_submessages(), OpenDDS::STUN::Message::compute_fingerprint(), OpenDDS::STUN::Message::compute_message_integrity(), OpenDDS::RTPS::Sedp::Reader::data_received(), OpenDDS::DCPS::DataReaderImpl_T< MessageType >::dds_demarshal(), OpenDDS::DCPS::DataWriterImpl_T< MessageType >::dds_marshal(), OpenDDS::DCPS::RtpsUdpReceiveStrategy::decode_payload(), OpenDDS::DCPS::Serializer::doread(), OpenDDS::DCPS::Serializer::dowrite(), OpenDDS::DCPS::Serializer::endianness(), OpenDDS::RTPS::Spdp::SendStun::execute(), marshal_generator::gen_enum(), marshal_generator::gen_struct(), marshal_generator::gen_typedef(), OpenDDS::RTPS::get_locators_encoding(), OpenDDS::XTypes::get_typeobject_encoding(), OpenDDS::RTPS::Spdp::SpdpTransport::handle_input(), OpenDDS::DCPS::DataSampleHeader::init(), OpenDDS::RTPS::locators_to_blob(), OpenDDS::DCPS::FilterEvaluator::SerializedForEval::lookup(), OpenDDS::DCPS::DataReaderImpl_T< MessageType >::lookup_instance(), OpenDDS::XTypes::makeTypeIdentifier(), OpenDDS::RTPS::marshal_key_hash(), OpenDDS::Security::SSL::hash_serialized_impl::operator()(), OpenDDS::DCPS::operator<<(), OpenDDS::DCPS::operator>>(), OpenDDS::DCPS::DataSampleHeader::partial(), OpenDDS::RTPS::populate_locators(), OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::RtpsUdpReceiveStrategy::receive_bytes_helper(), OpenDDS::DCPS::DataWriterImpl::replay_durable_data_for(), OpenDDS::DCPS::RtpsUdpReceiveStrategy::sec_submsg_to_octets(), OpenDDS::DCPS::RtpsUdpTransport::IceEndpoint::send(), OpenDDS::XTypes::serialize_type_info(), OpenDDS::DCPS::set_default(), OpenDDS::RTPS::Sedp::shutting_down(), OpenDDS::Security::SSL::sign_serialized(), OpenDDS::DCPS::Serializer::skip(), OpenDDS::DCPS::DataSampleHeader::split(), typeobject_generator::strong_connect(), OpenDDS::DCPS::RtpsUdpDataLink::submsgs_to_msgblock(), OpenDDS::DCPS::Serializer::swap_bytes(), OpenDDS::DCPS::TypeSupportImpl::to_type_info(), OpenDDS::DCPS::Service_Participant::type_object_encoding(), OpenDDS::XTypes::TypeLookup_Reply::TypeLookup_Reply(), OpenDDS::Security::SSL::verify_serialized(), OpenDDS::DCPS::Serializer::write_delimiter(), and OpenDDS::DCPS::Serializer::write_list_end_parameter_id().

◆ make_error_code()

OpenDDS_Rtps_Export Attribute OpenDDS::STUN::make_error_code ( ACE_UINT16  code,
const std::string &  reason 
)

Definition at line 99 of file Stun.cpp.

References OpenDDS::STUN::Attribute::code, OpenDDS::STUN::Attribute::error, ERROR_CODE, OpenDDS::STUN::Attribute::reason, and OpenDDS::STUN::Attribute::type.

Referenced by OpenDDS::ICE::EndpointManager::make_bad_request_error_response(), OpenDDS::ICE::EndpointManager::make_unauthorized_error_response(), OpenDDS::ICE::EndpointManager::make_unknown_attributes_error_response(), and operator>>().

100 {
101  Attribute attribute;
102  attribute.type = ERROR_CODE;
103  attribute.error.code = code;
104  attribute.error.reason = reason;
105  return attribute;
106 }
code
Christopher Diggins *renamed files *fixing compilation errors *adding Visual C project file *removed make Max Lybbert *removed references to missing and unused as reported by Andy Elvey and Dan Kosecki *resynced with Christopher Diggins s branch as it exists in tree building code is back Christopher Diggins *resynced codebase with Chris s branch *removed tree building code
Definition: CHANGELOG.txt:8

◆ make_fingerprint()

OpenDDS_Rtps_Export Attribute OpenDDS::STUN::make_fingerprint ( )

Definition at line 139 of file Stun.cpp.

References FINGERPRINT, and OpenDDS::STUN::Attribute::type.

Referenced by OpenDDS::ICE::ConnectivityCheck::ConnectivityCheck(), OpenDDS::ICE::Checklist::execute(), OpenDDS::ICE::EndpointManager::make_bad_request_error_response(), OpenDDS::ICE::EndpointManager::make_unauthorized_error_response(), OpenDDS::ICE::EndpointManager::make_unknown_attributes_error_response(), OpenDDS::ICE::ServerReflexiveStateMachine::next_send(), operator>>(), OpenDDS::ICE::EndpointManager::request(), and OpenDDS::ICE::EndpointManager::server_reflexive_task().

140 {
141  Attribute attribute;
142  attribute.type = FINGERPRINT;
143  return attribute;
144 }

◆ make_guid_prefix()

OpenDDS_Rtps_Export Attribute OpenDDS::STUN::make_guid_prefix ( const DCPS::GuidPrefix_t &  guid_prefix)

Definition at line 163 of file Stun.cpp.

References GUID_PREFIX, OpenDDS::STUN::Attribute::guid_prefix, and OpenDDS::STUN::Attribute::type.

Referenced by OpenDDS::ICE::ServerReflexiveStateMachine::next_send(), and operator>>().

164 {
165  Attribute attribute;
166  attribute.type = GUID_PREFIX;
167  std::memcpy(attribute.guid_prefix, guid_prefix, sizeof(guid_prefix));
168  return attribute;
169 }

◆ make_ice_controlled()

OpenDDS_Rtps_Export Attribute OpenDDS::STUN::make_ice_controlled ( ACE_UINT64  ice_tie_breaker)

Definition at line 154 of file Stun.cpp.

References ICE_CONTROLLED, OpenDDS::STUN::Attribute::ice_tie_breaker, OpenDDS_Rtps_Export, and OpenDDS::STUN::Attribute::type.

Referenced by OpenDDS::ICE::ConnectivityCheck::ConnectivityCheck(), and operator>>().

155 {
156  Attribute attribute;
157  attribute.type = ICE_CONTROLLED;
158  attribute.ice_tie_breaker = ice_tie_breaker;
159  return attribute;
160 }

◆ make_ice_controlling()

OpenDDS_Rtps_Export Attribute OpenDDS::STUN::make_ice_controlling ( ACE_UINT64  ice_tie_breaker)

Definition at line 146 of file Stun.cpp.

References ICE_CONTROLLING, OpenDDS::STUN::Attribute::ice_tie_breaker, and OpenDDS::STUN::Attribute::type.

Referenced by OpenDDS::ICE::ConnectivityCheck::ConnectivityCheck(), and operator>>().

147 {
148  Attribute attribute;
149  attribute.type = ICE_CONTROLLING;
150  attribute.ice_tie_breaker = ice_tie_breaker;
151  return attribute;
152 }

◆ make_mapped_address()

OpenDDS_Rtps_Export Attribute OpenDDS::STUN::make_mapped_address ( const ACE_INET_Addr &  addr)

Definition at line 76 of file Stun.cpp.

References MAPPED_ADDRESS, OpenDDS::STUN::Attribute::mapped_address, and OpenDDS::STUN::Attribute::type.

Referenced by operator>>(), and OpenDDS::ICE::EndpointManager::request().

77 {
78  Attribute attribute;
79  attribute.type = MAPPED_ADDRESS;
80  attribute.mapped_address = addr;
81  return attribute;
82 }

◆ make_message_integrity()

OpenDDS_Rtps_Export Attribute OpenDDS::STUN::make_message_integrity ( )

Definition at line 92 of file Stun.cpp.

References MESSAGE_INTEGRITY, and OpenDDS::STUN::Attribute::type.

Referenced by OpenDDS::ICE::ConnectivityCheck::ConnectivityCheck(), OpenDDS::ICE::Checklist::execute(), OpenDDS::ICE::EndpointManager::make_bad_request_error_response(), OpenDDS::ICE::EndpointManager::make_unauthorized_error_response(), OpenDDS::ICE::EndpointManager::make_unknown_attributes_error_response(), operator>>(), and OpenDDS::ICE::EndpointManager::request().

93 {
94  Attribute attribute;
95  attribute.type = MESSAGE_INTEGRITY;
96  return attribute;
97 }

◆ make_priority()

OpenDDS_Rtps_Export Attribute OpenDDS::STUN::make_priority ( ACE_UINT32  priority)

Definition at line 124 of file Stun.cpp.

References PRIORITY, OpenDDS::STUN::Attribute::priority, and OpenDDS::STUN::Attribute::type.

Referenced by OpenDDS::ICE::ConnectivityCheck::ConnectivityCheck(), and operator>>().

125 {
126  Attribute attribute;
127  attribute.type = PRIORITY;
128  attribute.priority = priority;
129  return attribute;
130 }

◆ make_unknown_attribute()

OpenDDS_Rtps_Export Attribute OpenDDS::STUN::make_unknown_attribute ( ACE_UINT16  type,
ACE_UINT16  length 
)

Definition at line 171 of file Stun.cpp.

References OpenDDS::STUN::Attribute::length(), OpenDDS::STUN::Attribute::type, and OpenDDS::STUN::Attribute::unknown_length.

Referenced by operator>>().

172 {
173  Attribute attribute;
174  attribute.type = static_cast<AttributeType>(type);
175  attribute.unknown_length = length;
176  return attribute;
177 }
OpenDDS::STUN::AttributeType
AttributeType
Definition: Stun.h:55

◆ make_unknown_attributes()

OpenDDS_Rtps_Export Attribute OpenDDS::STUN::make_unknown_attributes ( const std::vector< AttributeType > &  unknown_attributes)

Definition at line 108 of file Stun.cpp.

References OpenDDS::STUN::Attribute::type, UNKNOWN_ATTRIBUTES, and OpenDDS::STUN::Attribute::unknown_attributes.

Referenced by OpenDDS::ICE::EndpointManager::make_unknown_attributes_error_response(), and operator>>().

109 {
110  Attribute attribute;
111  attribute.type = UNKNOWN_ATTRIBUTES;
112  attribute.unknown_attributes = unknown_attributes;
113  return attribute;
114 }

◆ make_use_candidate()

OpenDDS_Rtps_Export Attribute OpenDDS::STUN::make_use_candidate ( )

Definition at line 132 of file Stun.cpp.

References OpenDDS::STUN::Attribute::type, and USE_CANDIDATE.

Referenced by OpenDDS::ICE::ConnectivityCheck::ConnectivityCheck(), and operator>>().

133 {
134  Attribute attribute;
135  attribute.type = USE_CANDIDATE;
136  return attribute;
137 }

◆ make_username()

OpenDDS_Rtps_Export Attribute OpenDDS::STUN::make_username ( const std::string &  username)

Definition at line 84 of file Stun.cpp.

References OpenDDS::STUN::Attribute::type, USERNAME, and OpenDDS::STUN::Attribute::username.

Referenced by OpenDDS::ICE::ConnectivityCheck::ConnectivityCheck(), OpenDDS::ICE::Checklist::execute(), and operator>>().

85 {
86  Attribute attribute;
87  attribute.type = USERNAME;
88  attribute.username = username;
89  return attribute;
90 }

◆ make_xor_mapped_address()

OpenDDS_Rtps_Export Attribute OpenDDS::STUN::make_xor_mapped_address ( const ACE_INET_Addr &  addr)

Definition at line 116 of file Stun.cpp.

References OpenDDS::STUN::Attribute::mapped_address, OpenDDS::STUN::Attribute::type, and XOR_MAPPED_ADDRESS.

Referenced by operator>>(), and OpenDDS::ICE::EndpointManager::request().

117 {
118  Attribute attribute;
119  attribute.type = XOR_MAPPED_ADDRESS;
120  attribute.mapped_address = addr;
121  return attribute;
122 }

◆ operator<<() [1/2]

OpenDDS_Rtps_Export bool OpenDDS::STUN::operator<< ( DCPS::Serializer &  serializer,
ConstAttributeHolder &  holder 
)

Definition at line 462 of file Stun.cpp.

References OpenDDS::DCPS::address_to_bytes(), AF_INET, OpenDDS::STUN::ConstAttributeHolder::attribute, OpenDDS::STUN::Attribute::code, OpenDDS::STUN::TransactionId::data, OpenDDS::STUN::Attribute::error, ERROR_CODE, FINGERPRINT, OpenDDS::STUN::Attribute::fingerprint, ACE_INET_Addr::get_ip_address(), ACE_INET_Addr::get_port_number(), ACE_Addr::get_type(), GUID_PREFIX, OpenDDS::STUN::Attribute::guid_prefix, ICE_CONTROLLED, ICE_CONTROLLING, OpenDDS::STUN::Attribute::ice_tie_breaker, IPv4, IPv6, OpenDDS::STUN::Attribute::length(), MAGIC_COOKIE, MAPPED_ADDRESS, OpenDDS::STUN::Attribute::mapped_address, MESSAGE_INTEGRITY, OpenDDS::STUN::Attribute::message_integrity, PRIORITY, OpenDDS::STUN::Attribute::priority, OpenDDS::STUN::Attribute::reason, OpenDDS::STUN::ConstAttributeHolder::tid, OpenDDS::STUN::Attribute::type, UNKNOWN_ATTRIBUTES, OpenDDS::STUN::Attribute::unknown_attributes, USE_CANDIDATE, USERNAME, OpenDDS::STUN::Attribute::username, OpenDDS::DCPS::Serializer::write_octet_array(), and XOR_MAPPED_ADDRESS.

Referenced by OpenDDS::STUN::ConstAttributeHolder::ConstAttributeHolder().

463 {
464  ACE_UINT16 attribute_type = holder.attribute.type;
465  ACE_UINT16 attribute_length = holder.attribute.length();
466  serializer << attribute_type;
467  serializer << attribute_length;
468 
469  switch (attribute_type) {
470  case MAPPED_ADDRESS: {
471  serializer << static_cast<ACE_CDR::Char>(0);
472  if (holder.attribute.mapped_address.get_type() == AF_INET) {
473  serializer << static_cast<ACE_CDR::Char>(IPv4);
474  serializer << static_cast<ACE_UINT16>(holder.attribute.mapped_address.get_port_number());
475  serializer << holder.attribute.mapped_address.get_ip_address();
476  } else {
477  serializer << static_cast<ACE_CDR::Char>(IPv6);
478  serializer << static_cast<ACE_UINT16>(holder.attribute.mapped_address.get_port_number());
479  DDS::OctetArray16 a;
480  DCPS::address_to_bytes(a, holder.attribute.mapped_address);
481  serializer.write_octet_array(a, 16);
482  }
483  }
484  break;
485 
486  case USERNAME: {
487  serializer.write_octet_array(reinterpret_cast<const ACE_CDR::Octet*>(holder.attribute.username.c_str()),
488  static_cast<ACE_CDR::ULong>(holder.attribute.username.size()));
489  }
490  break;
491 
492  case MESSAGE_INTEGRITY: {
493  serializer.write_octet_array(holder.attribute.message_integrity, sizeof(holder.attribute.message_integrity));
494  }
495  break;
496 
497  case ERROR_CODE: {
498  ACE_UINT8 class_ = holder.attribute.error.code / 100;
499  ACE_UINT8 num = holder.attribute.error.code % 100;
500  serializer << static_cast<ACE_CDR::Char>(0);
501  serializer << static_cast<ACE_CDR::Char>(0);
502  serializer << static_cast<ACE_CDR::Char>(class_);
503  serializer << static_cast<ACE_CDR::Char>(num);
504  serializer.write_octet_array(reinterpret_cast<const ACE_CDR::Octet*>(holder.attribute.error.reason.c_str()),
505  static_cast<ACE_CDR::ULong>(holder.attribute.error.reason.size()));
506  }
507  break;
508 
509  case UNKNOWN_ATTRIBUTES: {
510  for (std::vector<AttributeType>::const_iterator pos = holder.attribute.unknown_attributes.begin(),
511  limit = holder.attribute.unknown_attributes.end(); pos != limit; ++pos) {
512  serializer << static_cast<ACE_UINT16>(*pos);
513  }
514  }
515  break;
516 
517  case XOR_MAPPED_ADDRESS: {
518  serializer << static_cast<ACE_CDR::Char>(0);
519  if (holder.attribute.mapped_address.get_type() == AF_INET) {
520  serializer << static_cast<ACE_CDR::Char>(IPv4);
521  serializer << static_cast<ACE_UINT16>(holder.attribute.mapped_address.get_port_number() ^ (MAGIC_COOKIE >> 16));
522  serializer << (holder.attribute.mapped_address.get_ip_address() ^ MAGIC_COOKIE);
523  } else {
524  serializer << static_cast<ACE_CDR::Char>(IPv6);
525  serializer << static_cast<ACE_UINT16>(holder.attribute.mapped_address.get_port_number() ^ (MAGIC_COOKIE >> 16));
526 
527  DDS::OctetArray16 a;
528  DCPS::address_to_bytes(a, holder.attribute.mapped_address);
529 
530  a[0] ^= ((MAGIC_COOKIE & 0xFF000000) >> 24);
531  a[1] ^= ((MAGIC_COOKIE & 0x00FF0000) >> 16);
532  a[2] ^= ((MAGIC_COOKIE & 0x0000FF00) >> 8);
533  a[3] ^= ((MAGIC_COOKIE & 0x000000FF) >> 0);
534  a[4] ^= holder.tid.data[0];
535  a[5] ^= holder.tid.data[1];
536  a[6] ^= holder.tid.data[2];
537  a[7] ^= holder.tid.data[3];
538  a[8] ^= holder.tid.data[4];
539  a[9] ^= holder.tid.data[5];
540  a[10] ^= holder.tid.data[6];
541  a[11] ^= holder.tid.data[7];
542  a[12] ^= holder.tid.data[8];
543  a[13] ^= holder.tid.data[9];
544  a[14] ^= holder.tid.data[10];
545  a[15] ^= holder.tid.data[11];
546 
547  serializer.write_octet_array(a, 16);
548  }
549  }
550  break;
551 
552  case PRIORITY: {
553  serializer << holder.attribute.priority;
554  }
555  break;
556 
557  case USE_CANDIDATE:
558  break;
559 
560  case FINGERPRINT: {
561  serializer << holder.attribute.fingerprint;
562  }
563  break;
564 
565  case ICE_CONTROLLED:
566  case ICE_CONTROLLING: {
567  serializer << holder.attribute.ice_tie_breaker;
568  }
569  break;
570 
571  case GUID_PREFIX: {
572  serializer.write_octet_array(holder.attribute.guid_prefix, sizeof(holder.attribute.guid_prefix));
573  }
574  break;
575 
576  default:
577  // Don't serialize attributes that are not understood.
578  return false;
579  break;
580  }
581 
582  // Align to 32 bits.
583  while (attribute_length % 4 != 0) {
584  serializer << static_cast<ACE_CDR::Char>(0);
585  attribute_length += 1;
586  }
587 
588  return true;
589 }
OpenDDS::DCPS::address_to_bytes
void address_to_bytes(DDS::OctetArray16 &dest, const ACE_INET_Addr &addr)
Definition: NetworkAddress.h:112
OpenDDS::STUN::MAGIC_COOKIE
const ACE_UINT32 MAGIC_COOKIE
Definition: Stun.h:48
AF_INET
#define AF_INET
ACE_UINT8
unsigned char ACE_UINT8
DDS::OctetArray16
octet OctetArray16[16]
Definition: DdsDcpsCore.idl:390

◆ operator<<() [2/2]

OpenDDS_Rtps_Export bool OpenDDS::STUN::operator<< ( DCPS::Serializer &  serializer,
const Message &  message 
)

Definition at line 944 of file Stun.cpp.

References OpenDDS::STUN::Message::begin(), OpenDDS::STUN::Message::class_, OpenDDS::STUN::Message::compute_fingerprint(), OpenDDS::STUN::Message::compute_message_integrity(), OpenDDS::STUN::TransactionId::data, OpenDDS::STUN::Message::end(), FINGERPRINT, OpenDDS::STUN::Attribute::fingerprint, OpenDDS::STUN::Message::length(), MAGIC_COOKIE, MESSAGE_INTEGRITY, OpenDDS::STUN::Message::method, OPENDDS_END_VERSIONED_NAMESPACE_DECL, OpenDDS::STUN::Message::password, OpenDDS::STUN::Message::transaction_id, OpenDDS::STUN::Attribute::type, and OpenDDS::DCPS::Serializer::write_octet_array().

945 {
946  ACE_UINT16 message_class = message.class_;
947  ACE_UINT16 message_method = message.method;
948  ACE_UINT16 message_type =
949  ((message_method & 0xF80) << 2) |
950  ((message_class & 0x2) << 7) |
951  ((message_method & 0x0070) << 1) |
952  ((message_class & 0x1) << 4) |
953  (message_method & 0x000F);
954  serializer << message_type;
955 
956  ACE_UINT16 message_length = message.length();
957  serializer << message_length;
958  serializer << MAGIC_COOKIE;
959  serializer.write_octet_array(message.transaction_id.data, sizeof(message.transaction_id.data));
960 
961  for (Message::const_iterator pos = message.begin(), limit = message.end();
962  pos != limit; ++pos) {
963  const Attribute& attribute = *pos;
964 
965  if (attribute.type == MESSAGE_INTEGRITY) {
966  // Compute the hash.
967  message.compute_message_integrity(message.password, const_cast<Attribute&>(attribute).message_integrity);
968  }
969 
970  else if (attribute.type == FINGERPRINT) {
971  // Compute the hash.
972  const_cast<Attribute&>(attribute).fingerprint = message.compute_fingerprint();
973  }
974 
975  ConstAttributeHolder holder(attribute, message.transaction_id);
976  serializer << holder;
977  }
978 
979  return true;
980 }
OpenDDS::STUN::MAGIC_COOKIE
const ACE_UINT32 MAGIC_COOKIE
Definition: Stun.h:48

◆ operator>>() [1/2]

OpenDDS_Rtps_Export bool OpenDDS::STUN::operator>> ( DCPS::Serializer &  serializer,
AttributeHolder &  holder 
)

Definition at line 179 of file Stun.cpp.

References OpenDDS::STUN::AttributeHolder::attribute, OpenDDS::STUN::Attribute::code, OpenDDS::STUN::TransactionId::data, ERROR_CODE, FINGERPRINT, OpenDDS::STUN::Attribute::fingerprint, GUID_PREFIX, OpenDDS::STUN::Attribute::guid_prefix, ICE_CONTROLLED, ICE_CONTROLLING, OpenDDS::STUN::Attribute::ice_tie_breaker, IPv4, IPv6, MAGIC_COOKIE, make_error_code(), make_fingerprint(), make_guid_prefix(), make_ice_controlled(), make_ice_controlling(), make_mapped_address(), make_message_integrity(), make_priority(), make_unknown_attribute(), make_unknown_attributes(), make_use_candidate(), make_username(), make_xor_mapped_address(), MAPPED_ADDRESS, MESSAGE_INTEGRITY, OpenDDS::STUN::Attribute::message_integrity, PRIORITY, OpenDDS::STUN::Attribute::priority, OpenDDS::DCPS::Serializer::read_octet_array(), ACE_INET_Addr::set_address(), ACE_INET_Addr::set_port_number(), ACE_Addr::set_type(), OpenDDS::DCPS::Serializer::skip(), OpenDDS::STUN::AttributeHolder::tid, UNKNOWN_ATTRIBUTES, OpenDDS::STUN::Attribute::unknown_attributes, USE_CANDIDATE, USERNAME, and XOR_MAPPED_ADDRESS.

Referenced by OpenDDS::STUN::ConstAttributeHolder::ConstAttributeHolder().

180 {
181  ACE_UINT16 attribute_type;
182  ACE_UINT16 attribute_length;
183 
184  if (!(serializer >> attribute_type)) {
185  return false;
186  }
187 
188  if (!(serializer >> attribute_length)) {
189  return false;
190  }
191 
192  switch (attribute_type) {
193  case MAPPED_ADDRESS: {
194  ACE_CDR::Char family;
195  ACE_UINT16 port;
196 
197  if (!serializer.skip(1)) {
198  return false;
199  }
200 
201  if (!(serializer >> family)) {
202  return false;
203  }
204 
205  if (!(serializer >> port)) {
206  return false;
207  }
208 
209  if (family == IPv4) {
210  if (attribute_length != 8) {
211  return false;
212  }
213 
214  ACE_UINT32 address;
215 
216  if (!(serializer >> address)) {
217  return false;
218  }
219 
220  holder.attribute = make_mapped_address(ACE_INET_Addr(port, address));
221  } else if (family == IPv6) {
222  if (attribute_length != 20) {
223  return false;
224  }
225 
226  ACE_CDR::Octet address[16];
227 
228  if (!(serializer.read_octet_array(address, 16))) {
229  return false;
230  }
231  ACE_INET_Addr addr;
232  addr.set_type(AF_INET6);
233  addr.set_address(reinterpret_cast<const char*>(address), 16, 0);
234  addr.set_port_number(port);
235 
236  holder.attribute = make_mapped_address(addr);
237  }
238  }
239  break;
240 
241  case USERNAME: {
242  if (attribute_length > 512) {
243  return false;
244  }
245 
246  unsigned char buffer[512];
247 
248  if (!serializer.read_octet_array(buffer, attribute_length)) {
249  return false;
250  }
251 
252  holder.attribute = make_username(std::string(reinterpret_cast<char*>(buffer), attribute_length));
253  }
254  break;
255 
256  case MESSAGE_INTEGRITY: {
257  holder.attribute = make_message_integrity();
258 
259  if (!serializer.read_octet_array(holder.attribute.message_integrity, sizeof(holder.attribute.message_integrity))) {
260  return false;
261  }
262  }
263  break;
264 
265  case ERROR_CODE: {
266  ACE_UINT32 x;
267 
268  if (!(serializer >> x)) {
269  return false;
270  }
271 
272  ACE_UINT32 class_ = (x & (0x7 << 8)) >> 8;
273 
274  if (class_ < 3 || class_ >= 7) {
275  return false;
276  }
277 
278  ACE_UINT32 num = x & 0xFF;
279 
280  if (num > 100) {
281  return false;
282  }
283 
284  ACE_UINT16 code = class_ * 100 + num;
285 
286  const ACE_CDR::ULong reason_length = attribute_length - 4;
287 
288  if (reason_length > 763) {
289  return false;
290  }
291 
292  unsigned char buffer[763];
293 
294  if (!serializer.read_octet_array(buffer, reason_length)) {
295  return false;
296  }
297 
298  holder.attribute = make_error_code(code, std::string(reinterpret_cast<char*>(buffer), reason_length));
299  }
300  break;
301 
302  case UNKNOWN_ATTRIBUTES: {
303  std::vector<AttributeType> unknown_attributes;
304 
305  for (size_t count = attribute_length / 2; count != 0; --count) {
306  ACE_UINT16 code;
307 
308  if (!(serializer >> code)) {
309  return false;
310  }
311 
312  unknown_attributes.push_back(static_cast<AttributeType>(code));
313  }
314 
315  holder.attribute = make_unknown_attributes(unknown_attributes);
316  }
317  break;
318 
319  case XOR_MAPPED_ADDRESS: {
320  ACE_CDR::Char family;
321  ACE_UINT16 port;
322 
323  if (!serializer.skip(1)) {
324  return false;
325  }
326 
327  if (!(serializer >> family)) {
328  return false;
329  }
330 
331  if (!(serializer >> port)) {
332  return false;
333  }
334 
335  port ^= MAGIC_COOKIE >> 16;
336 
337  if (family == IPv4) {
338  if (attribute_length != 8) {
339  return false;
340  }
341 
342  ACE_UINT32 address;
343 
344  if (!(serializer >> address)) {
345  return false;
346  }
347 
348  address ^= MAGIC_COOKIE;
349  holder.attribute = make_xor_mapped_address(ACE_INET_Addr(port, address));
350  } else if (family == IPv6) {
351  if (attribute_length != 20) {
352  return false;
353  }
354 
355  ACE_CDR::Octet address[16];
356 
357  if (!(serializer.read_octet_array(address, 16))) {
358  return false;
359  }
360 
361  address[0] ^= ((MAGIC_COOKIE & 0xFF000000) >> 24);
362  address[1] ^= ((MAGIC_COOKIE & 0x00FF0000) >> 16);
363  address[2] ^= ((MAGIC_COOKIE & 0x0000FF00) >> 8);
364  address[3] ^= ((MAGIC_COOKIE & 0x000000FF) >> 0);
365  address[4] ^= holder.tid.data[0];
366  address[5] ^= holder.tid.data[1];
367  address[6] ^= holder.tid.data[2];
368  address[7] ^= holder.tid.data[3];
369  address[8] ^= holder.tid.data[4];
370  address[9] ^= holder.tid.data[5];
371  address[10] ^= holder.tid.data[6];
372  address[11] ^= holder.tid.data[7];
373  address[12] ^= holder.tid.data[8];
374  address[13] ^= holder.tid.data[9];
375  address[14] ^= holder.tid.data[10];
376  address[15] ^= holder.tid.data[11];
377 
378  ACE_INET_Addr addr;
379  addr.set_type(AF_INET6);
380  addr.set_address(reinterpret_cast<const char*>(address), 16, 0);
381  addr.set_port_number(port);
382 
383  holder.attribute = make_xor_mapped_address(addr);
384  }
385  }
386  break;
387 
388  case PRIORITY: {
389  ACE_UINT32 priority;
390 
391  if (!(serializer >> priority)) {
392  return false;
393  }
394 
395  holder.attribute = make_priority(priority);
396  }
397  break;
398 
399  case USE_CANDIDATE:
400  holder.attribute = make_use_candidate();
401  break;
402 
403  case FINGERPRINT: {
404  holder.attribute = make_fingerprint();
405 
406  if (!(serializer >> holder.attribute.fingerprint)) {
407  return false;
408  }
409  }
410  break;
411 
412  case ICE_CONTROLLED: {
413  ACE_UINT64 ice_tie_breaker;
414 
415  if (!(serializer >> ice_tie_breaker)) {
416  return false;
417  }
418 
419  holder.attribute = make_ice_controlled(ice_tie_breaker);
420  }
421  break;
422 
423  case ICE_CONTROLLING: {
424  ACE_UINT64 ice_tie_breaker;
425 
426  if (!(serializer >> ice_tie_breaker)) {
427  return false;
428  }
429 
430  holder.attribute = make_ice_controlling(ice_tie_breaker);
431  }
432  break;
433 
434  case GUID_PREFIX: {
435  DCPS::GuidPrefix_t guid_prefix;
436  if (!(serializer.read_octet_array(guid_prefix, sizeof(guid_prefix)))) {
437  return false;
438  }
439 
440  holder.attribute = make_guid_prefix(guid_prefix);
441  }
442  break;
443 
444  default: {
445  if (!serializer.skip(attribute_length)) {
446  return false;
447  }
448 
449  holder.attribute = make_unknown_attribute(attribute_type, attribute_length);
450  }
451  break;
452  }
453 
454  // All attributes are aligned on 32-bit boundaries.
455  if (!serializer.skip((4 - (attribute_length & 0x3)) % 4)) {
456  return false;
457  }
458 
459  return true;
460 }
ACE_CDR::Octet
ACE_Byte Octet
OpenDDS::STUN::make_unknown_attributes
Attribute make_unknown_attributes(const std::vector< AttributeType > &unknown_attributes)
Definition: Stun.cpp:108
OpenDDS::STUN::make_mapped_address
Attribute make_mapped_address(const ACE_INET_Addr &addr)
Definition: Stun.cpp:76
OpenDDS::STUN::make_priority
Attribute make_priority(ACE_UINT32 priority)
Definition: Stun.cpp:124
OpenDDS::STUN::make_username
Attribute make_username(const std::string &username)
Definition: Stun.cpp:84
OpenDDS::STUN::MAGIC_COOKIE
const ACE_UINT32 MAGIC_COOKIE
Definition: Stun.h:48
OpenDDS::STUN::make_error_code
Attribute make_error_code(ACE_UINT16 code, const std::string &reason)
Definition: Stun.cpp:99
ACE_Addr::set_type
void set_type(int type)
OpenDDS::STUN::make_ice_controlling
Attribute make_ice_controlling(ACE_UINT64 ice_tie_breaker)
Definition: Stun.cpp:146
ACE_CDR::Char
char Char
OpenDDS::STUN::make_unknown_attribute
Attribute make_unknown_attribute(ACE_UINT16 type, ACE_UINT16 length)
Definition: Stun.cpp:171
ACE_INET_Addr::set_address
int set_address(const char *ip_addr, int len, int encode=1, int map=0)
code
Christopher Diggins *renamed files *fixing compilation errors *adding Visual C project file *removed make Max Lybbert *removed references to missing and unused as reported by Andy Elvey and Dan Kosecki *resynced with Christopher Diggins s branch as it exists in tree building code is back Christopher Diggins *resynced codebase with Chris s branch *removed tree building code
Definition: CHANGELOG.txt:8
ACE_CDR::ULong
ACE_UINT32 ULong
OpenDDS::DCPS::GuidPrefix_t
octet GuidPrefix_t[12]
Definition: DdsDcpsGuid.idl:19
ACE_UINT64
unsigned long long ACE_UINT64
OpenDDS::STUN::make_message_integrity
Attribute make_message_integrity()
Definition: Stun.cpp:92
OpenDDS::STUN::make_use_candidate
Attribute make_use_candidate()
Definition: Stun.cpp:132
OpenDDS::STUN::make_ice_controlled
Attribute make_ice_controlled(ACE_UINT64 ice_tie_breaker)
Definition: Stun.cpp:154
OpenDDS::STUN::make_fingerprint
Attribute make_fingerprint()
Definition: Stun.cpp:139
ACE_INET_Addr::set_port_number
void set_port_number(u_short, int encode=1)
OpenDDS::STUN::make_guid_prefix
OpenDDS_Rtps_Export Attribute make_guid_prefix(const DCPS::GuidPrefix_t &guid_prefix)
Definition: Stun.cpp:163
OpenDDS::STUN::make_xor_mapped_address
Attribute make_xor_mapped_address(const ACE_INET_Addr &addr)
Definition: Stun.cpp:116

◆ operator>>() [2/2]

OpenDDS_Rtps_Export bool OpenDDS::STUN::operator>> ( DCPS::Serializer &  serializer,
Message &  message 
)

Definition at line 870 of file Stun.cpp.

References OpenDDS::STUN::Message::append_attribute(), OpenDDS::STUN::Message::class_, OpenDDS::STUN::Message::compute_fingerprint(), OpenDDS::STUN::TransactionId::data, FINGERPRINT, OpenDDS::STUN::Attribute::fingerprint, OpenDDS::STUN::Message::length(), OpenDDS::DCPS::Serializer::length(), MAGIC_COOKIE, MESSAGE_INTEGRITY, OpenDDS::STUN::Message::method, OpenDDS::DCPS::Serializer::read_octet_array(), OpenDDS::STUN::Message::transaction_id, and OpenDDS::STUN::Attribute::type.

871 {
872  ACE_UINT16 message_type;
873  ACE_UINT16 message_length;
874  ACE_UINT32 magic_cookie;
875 
876  if (!(serializer >> message_type)) {
877  return false;
878  }
879 
880  if (!(serializer >> message_length)) {
881  return false;
882  }
883 
884  if ((message_type & 0xC000) != 0) {
885  return false;
886  }
887 
888  if (message_length % 4 != 0) {
889  return false;
890  }
891 
892  message.class_ = static_cast<Class>(((message_type & (1 << 8)) >> 7) | ((message_type & (1 << 4)) >> 4));
893  message.method = static_cast<Method>(((message_type & 0x3E00) >> 2) | ((message_type & 0xE0) >> 1) | (message_type & 0xF));
894 
895  if (!(serializer >> magic_cookie)) {
896  return false;
897  }
898 
899  if (magic_cookie != MAGIC_COOKIE) {
900  return false;
901  }
902 
903  if (!serializer.read_octet_array(message.transaction_id.data, 12)) {
904  return false;
905  }
906 
907  // At this point there should be message.length bytes remaining.
908  if (serializer.length() != message_length) {
909  return false;
910  }
911 
912  bool have_integrity = false;
913  bool have_fingerprint = false;
914 
915  while (serializer.length() != 0) {
916  Attribute attribute;
917  AttributeHolder holder(attribute, message.transaction_id);
918 
919  if (!(serializer >> holder)) {
920  return false;
921  }
922 
923  message.append_attribute(attribute);
924 
925  if ((have_integrity && attribute.type != FINGERPRINT) || have_fingerprint) {
926  return false;
927  }
928 
929  if (attribute.type == FINGERPRINT && attribute.fingerprint != message.compute_fingerprint()) {
930  return false;
931  }
932 
933  if (message.length() > message_length) {
934  return false;
935  }
936 
937  have_integrity = have_integrity || attribute.type == MESSAGE_INTEGRITY;
938  have_fingerprint = have_fingerprint || attribute.type == FINGERPRINT;
939  }
940 
941  return true;
942 }
OpenDDS::STUN::MAGIC_COOKIE
const ACE_UINT32 MAGIC_COOKIE
Definition: Stun.h:48

Variable Documentation

◆ BAD_REQUEST

const ACE_UINT16 OpenDDS::STUN::BAD_REQUEST = 400

Definition at line 51 of file Stun.h.

Referenced by OpenDDS::ICE::Checklist::error_response(), and OpenDDS::ICE::EndpointManager::make_bad_request_error_response().

◆ HEADER_SIZE

const size_t OpenDDS::STUN::HEADER_SIZE = 20

Definition at line 49 of file Stun.h.

Referenced by OpenDDS::STUN::Message::compute_fingerprint(), and OpenDDS::STUN::Message::compute_message_integrity().

◆ MAGIC_COOKIE

const ACE_UINT32 OpenDDS::STUN::MAGIC_COOKIE = 0x2112A442

Definition at line 48 of file Stun.h.

Referenced by operator<<(), and operator>>().

◆ UNAUTHORIZED

const ACE_UINT16 OpenDDS::STUN::UNAUTHORIZED = 401

Definition at line 52 of file Stun.h.

Referenced by OpenDDS::ICE::EndpointManager::make_unauthorized_error_response().

◆ UNKNOWN_ATTRIBUTE

const ACE_UINT16 OpenDDS::STUN::UNKNOWN_ATTRIBUTE = 420

Definition at line 53 of file Stun.h.

Referenced by OpenDDS::ICE::Checklist::error_response(), OpenDDS::ICE::EndpointManager::error_response(), OpenDDS::ICE::ServerReflexiveStateMachine::error_response(), and OpenDDS::ICE::EndpointManager::make_unknown_attributes_error_response().

Generated by   doxygen 1.8.13