#include <Ice.h>

Collaboration diagram for OpenDDS::ICE::ServerReflexiveStateMachine:

[legend]

Public Types
enum	StateChange { SRSM_None, SRSM_Set, SRSM_Unset, SRSM_Change }

Public Member Functions
	ServerReflexiveStateMachine ()

StateChange	send (const ACE_INET_Addr &address, size_t indication_count_limit, const DCPS::GuidPrefix_t &guid_prefix)

StateChange	receive (const STUN::Message &message)

const STUN::Message &	message () const

const ACE_INET_Addr &	unset_stun_server_address () const

const ACE_INET_Addr &	stun_server_address () const

bool	is_response (const STUN::Message &message) const

DCPS::TimeDuration	latency () const

bool	latency_available () const

void	latency_available (bool flag)

bool	connected () const

Private Member Functions
StateChange	start (const ACE_INET_Addr &address, size_t indication_count_limit, const DCPS::GuidPrefix_t &guid_prefix)

StateChange	stop ()

StateChange	next_send (size_t indication_count_limit, const DCPS::GuidPrefix_t &guid_prefix)

StateChange	success_response (const STUN::Message &message)

StateChange	error_response (const STUN::Message &message)

Private Attributes
STUN::Class	message_class_

STUN::Message	message_

ACE_INET_Addr	unset_stun_server_address_

ACE_INET_Addr	stun_server_address_

ACE_INET_Addr	server_reflexive_address_

size_t	send_count_

DCPS::MonotonicTimePoint	timestamp_

DCPS::TimeDuration	latency_

bool	latency_available_

Detailed Description

Definition at line 211 of file RTPS/ICE/Ice.h.

Member Enumeration Documentation

◆ StateChange

enum OpenDDS::ICE::ServerReflexiveStateMachine::StateChange

Enumerator
SRSM_None
SRSM_Set
SRSM_Unset
SRSM_Change

Definition at line 213 of file RTPS/ICE/Ice.h.

                    {
     SRSM_None,
     SRSM_Set,
     SRSM_Unset,
     SRSM_Change
   };

Constructor & Destructor Documentation

◆ ServerReflexiveStateMachine()

OpenDDS::ICE::ServerReflexiveStateMachine::ServerReflexiveStateMachine ( )

inline

Definition at line 220 of file RTPS/ICE/Ice.h.

References send().

     : message_class_(STUN::REQUEST)
     , send_count_(0)
     , latency_available_(false)
   {}

Member Function Documentation

◆ connected()

bool OpenDDS::ICE::ServerReflexiveStateMachine::connected ( ) const

inline

Definition at line 261 of file RTPS/ICE/Ice.h.

   {
     return server_reflexive_address_ != ACE_INET_Addr();
   }

◆ error_response()

ServerReflexiveStateMachine::StateChange OpenDDS::ICE::ServerReflexiveStateMachine::error_response ( const STUN::Message & message )

private

Definition at line 289 of file Ice.cpp.

References ACE_ERROR, ACE_TEXT(), OpenDDS::STUN::BINDING, OpenDDS::DCPS::DCPS_debug_level, OpenDDS::STUN::Message::get_error_code(), OpenDDS::STUN::Message::get_error_reason(), OpenDDS::STUN::Message::get_unknown_attributes(), OpenDDS::STUN::Message::has_error_code(), OpenDDS::STUN::Message::has_unknown_attributes(), LM_WARNING, OpenDDS::STUN::Message::method, OPENDDS_END_VERSIONED_NAMESPACE_DECL, and OpenDDS::STUN::UNKNOWN_ATTRIBUTE.

 {
   if (message.method != STUN::BINDING) {
     if (DCPS::DCPS_debug_level > 0) {
       ACE_ERROR((LM_WARNING,
                  ACE_TEXT("(%P|%t) ServerReflexiveStateMachine::error_response: "
                           "WARNING Unsupported STUN method\n")));
     }
     return SRSM_None;
   }
 
 
   if (!message.has_error_code()) {
     if (DCPS::DCPS_debug_level > 0) {
       ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) ServerReflexiveStateMachine::error_response: "
                                       "WARNING No error code\n")));
     }
     return SRSM_None;
   }
 
   if (DCPS::DCPS_debug_level > 0) {
     ACE_ERROR((LM_WARNING,
                ACE_TEXT("(%P|%t) ServerReflexiveStateMachine::error_response: "
                         "WARNING STUN error response code=%d reason=%C\n"),
                message.get_error_code(),
                message.get_error_reason().c_str()));
 
     if (message.get_error_code() == STUN::UNKNOWN_ATTRIBUTE && message.has_unknown_attributes()) {
       std::vector<STUN::AttributeType> unknown_attributes = message.get_unknown_attributes();
 
       for (std::vector<STUN::AttributeType>::const_iterator pos = unknown_attributes.begin(),
              limit = unknown_attributes.end(); pos != limit; ++pos) {
         ACE_ERROR((LM_WARNING,
                    ACE_TEXT("(%P|%t) ServerReflexiveStateMachine::error_response: "
                             "WARNING Unknown STUN attribute %d\n"),
                    *pos));
       }
     }
   }
 
   return SRSM_None;
 }

◆ is_response()

bool OpenDDS::ICE::ServerReflexiveStateMachine::is_response ( const STUN::Message & message ) const

inline

Definition at line 241 of file RTPS/ICE/Ice.h.

References OpenDDS::STUN::Message::transaction_id.

Referenced by OpenDDS::RTPS::Spdp::SpdpTransport::handle_input().

   {
     return message.transaction_id == message_.transaction_id;
   }

◆ latency()

DCPS::TimeDuration OpenDDS::ICE::ServerReflexiveStateMachine::latency ( void ) const

inline

Definition at line 246 of file RTPS/ICE/Ice.h.

Referenced by OpenDDS::DCPS::RtpsUdpTransport::process_relay_sra(), and OpenDDS::RTPS::Spdp::SpdpTransport::process_relay_sra().

   {
     return latency_;
   }

◆ latency_available() [1/2]

bool OpenDDS::ICE::ServerReflexiveStateMachine::latency_available ( ) const

inline

Definition at line 251 of file RTPS/ICE/Ice.h.

Referenced by OpenDDS::DCPS::RtpsUdpTransport::process_relay_sra(), and OpenDDS::RTPS::Spdp::SpdpTransport::process_relay_sra().

   {
     return latency_available_;
   }

◆ latency_available() [2/2]

void OpenDDS::ICE::ServerReflexiveStateMachine::latency_available ( bool flag )

inline

Definition at line 256 of file RTPS/ICE/Ice.h.

   {
     latency_available_ = flag;
   }

◆ message()

const STUN::Message& OpenDDS::ICE::ServerReflexiveStateMachine::message ( void ) const

inline

Definition at line 237 of file RTPS/ICE/Ice.h.

Referenced by OpenDDS::DCPS::RtpsUdpTransport::relay_stun_task(), and OpenDDS::RTPS::Spdp::SpdpTransport::relay_stun_task().

237 { return message_; }

OpenDDS::ICE::ServerReflexiveStateMachine::message_

STUN::Message message_

Definition: RTPS/ICE/Ice.h:274

◆ next_send()

ServerReflexiveStateMachine::StateChange OpenDDS::ICE::ServerReflexiveStateMachine::next_send	(	size_t	indication_count_limit,
		const DCPS::GuidPrefix_t &	guid_prefix
	)

private

Definition at line 209 of file Ice.cpp.

References OpenDDS::STUN::BINDING, OpenDDS::STUN::INDICATION, OpenDDS::STUN::make_fingerprint(), OpenDDS::STUN::make_guid_prefix(), and OpenDDS::STUN::REQUEST.

 {
   StateChange retval = SRSM_None;
 
   if (message_class_ == STUN::REQUEST &&
       server_reflexive_address_ != ACE_INET_Addr() &&
       send_count_ == indication_count_limit) {
     // Reset.
     retval = SRSM_Unset;
     server_reflexive_address_ = ACE_INET_Addr();
     unset_stun_server_address_ = stun_server_address_;
   }
 
   // indication_count_limit is offset by 1 to account for sending the request.
   if ((server_reflexive_address_ == ACE_INET_Addr()) ||
       (message_class_ == STUN::INDICATION && send_count_ >= indication_count_limit + 1)) {
     message_class_ = STUN::REQUEST;
     send_count_ = 0;
   }
 
   message_ = STUN::Message();
   message_.class_ = message_class_;
   message_.method = STUN::BINDING;
   message_.generate_transaction_id();
   message_.append_attribute(STUN::make_guid_prefix(guid_prefix));
   message_.append_attribute(STUN::make_fingerprint());
 
   ++send_count_;
 
   return retval;
 }

◆ receive()

ServerReflexiveStateMachine::StateChange OpenDDS::ICE::ServerReflexiveStateMachine::receive ( const STUN::Message & message )

Definition at line 156 of file Ice.cpp.

References ACE_ERROR, ACE_TEXT(), OpenDDS::STUN::Message::class_, OpenDDS::STUN::ERROR_RESPONSE, OpenDDS::STUN::INDICATION, LM_WARNING, OpenDDS::DCPS::TimePoint_T< MonotonicClock >::now(), OpenDDS::STUN::REQUEST, and OpenDDS::STUN::SUCCESS_RESPONSE.

Referenced by OpenDDS::RTPS::Spdp::SpdpTransport::handle_input().

 {
   latency_ = DCPS::MonotonicTimePoint::now() - timestamp_;
   latency_available_ = true;
 
   switch (message.class_) {
   case STUN::SUCCESS_RESPONSE:
     return success_response(message);
 
   case STUN::ERROR_RESPONSE:
     return error_response(message);
 
   case STUN::REQUEST:
   case STUN::INDICATION:
     ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) ServerReflexiveStateMachine::receive: WARNING Unsupported STUN message class %d\n"), message.class_));
     return SRSM_None;
   }
 
   ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) ServerReflexiveStateMachine::receive: WARNING Unknown STUN message class %d\n"), message.class_));
   return SRSM_None;
 }

◆ send()

ServerReflexiveStateMachine::StateChange OpenDDS::ICE::ServerReflexiveStateMachine::send	(	const ACE_INET_Addr &	address,
		size_t	indication_count_limit,
		const DCPS::GuidPrefix_t &	guid_prefix
	)

Definition at line 128 of file Ice.cpp.

References OpenDDS::DCPS::TimePoint_T< MonotonicClock >::now().

Referenced by OpenDDS::DCPS::RtpsUdpTransport::relay_stun_task(), and OpenDDS::RTPS::Spdp::SpdpTransport::relay_stun_task().

 {
   timestamp_ = DCPS::MonotonicTimePoint::now();
 
   if (stun_server_address_ == ACE_INET_Addr() &&
       address == ACE_INET_Addr()) {
     // Do nothing.
     return SRSM_None;
   } else if (stun_server_address_ == ACE_INET_Addr() &&
              address != ACE_INET_Addr()) {
     return start(address, indication_count_limit, guid_prefix);
   } else if (stun_server_address_ != ACE_INET_Addr() &&
              address == ACE_INET_Addr()) {
     return stop();
   } else {
     if (stun_server_address_ != address) {
       const StateChange retval = stop();
       start(address, indication_count_limit, guid_prefix);
       return retval;
     } else {
       return next_send(indication_count_limit, guid_prefix);
     }
   }
 }

◆ start()

ServerReflexiveStateMachine::StateChange OpenDDS::ICE::ServerReflexiveStateMachine::start	(	const ACE_INET_Addr &	address,
		size_t	indication_count_limit,
		const DCPS::GuidPrefix_t &	guid_prefix
	)

private

Definition at line 179 of file Ice.cpp.

References OPENDDS_ASSERT, and OpenDDS::STUN::REQUEST.

 {
   OPENDDS_ASSERT(address != ACE_INET_Addr());
   OPENDDS_ASSERT(stun_server_address_ == ACE_INET_Addr());
 
   // Send a binding request.
   message_class_ = STUN::REQUEST;
   send_count_ = 0;
 
   stun_server_address_ = address;
   server_reflexive_address_ = ACE_INET_Addr();
 
   return next_send(indication_count_limit, guid_prefix);
 }

◆ stop()

ServerReflexiveStateMachine::StateChange OpenDDS::ICE::ServerReflexiveStateMachine::stop ( void )

private

Definition at line 197 of file Ice.cpp.

References OPENDDS_ASSERT.

 {
   OPENDDS_ASSERT(stun_server_address_ != ACE_INET_Addr());
   const StateChange retval = server_reflexive_address_ != ACE_INET_Addr() ? SRSM_Unset : SRSM_None;
   unset_stun_server_address_ = stun_server_address_;
   stun_server_address_ = ACE_INET_Addr();
   server_reflexive_address_ = ACE_INET_Addr();
   send_count_ = 0;
   return retval;
 }

◆ stun_server_address()

const ACE_INET_Addr& OpenDDS::ICE::ServerReflexiveStateMachine::stun_server_address ( ) const

inline

Definition at line 239 of file RTPS/ICE/Ice.h.

Referenced by OpenDDS::DCPS::RtpsUdpTransport::disable_relay_stun_task(), OpenDDS::RTPS::Spdp::SpdpTransport::disable_relay_stun_task(), OpenDDS::DCPS::RtpsUdpTransport::process_relay_sra(), and OpenDDS::RTPS::Spdp::SpdpTransport::process_relay_sra().

239 { return stun_server_address_; }

OpenDDS::ICE::ServerReflexiveStateMachine::stun_server_address_

ACE_INET_Addr stun_server_address_

Definition: RTPS/ICE/Ice.h:276

◆ success_response()

ServerReflexiveStateMachine::StateChange OpenDDS::ICE::ServerReflexiveStateMachine::success_response ( const STUN::Message & message )

private

Definition at line 243 of file Ice.cpp.

References ACE_ERROR, ACE_TEXT(), OpenDDS::DCPS::DCPS_debug_level, OpenDDS::STUN::Message::get_mapped_address(), OpenDDS::STUN::INDICATION, LM_WARNING, and OpenDDS::STUN::Message::unknown_comprehension_required_attributes().

 {
   std::vector<STUN::AttributeType> unknown_attributes = message.unknown_comprehension_required_attributes();
 
   if (!unknown_attributes.empty()) {
     if (DCPS::DCPS_debug_level > 0) {
       ACE_ERROR((LM_WARNING,
                  ACE_TEXT("(%P|%t) ServerReflexiveStateMachine::success_response: "
                           "WARNING Unknown comprehension required attributes\n")));
     }
     return SRSM_None;
   }
 
   ACE_INET_Addr server_reflexive_address;
 
   if (!message.get_mapped_address(server_reflexive_address)) {
     if (DCPS::DCPS_debug_level > 0) {
       ACE_ERROR((LM_WARNING,
                  ACE_TEXT("(%P|%t) ServerReflexiveStateMachine::success_response: "
                           "WARNING No (XOR)_MAPPED_ADDRESS attribute\n")));
     }
     return SRSM_None;
   }
 
   if (server_reflexive_address == ACE_INET_Addr()) {
     if (DCPS::DCPS_debug_level > 0) {
       ACE_ERROR((LM_WARNING,
                  ACE_TEXT("(%P|%t) ServerReflexiveStateMachine::success_response: "
                           "WARNING (XOR)_MAPPED_ADDRESS is not valid\n")));
     }
     return SRSM_None;
   }
 
   message_class_ = STUN::INDICATION;
   if (server_reflexive_address == server_reflexive_address_) {
     return SRSM_None;
   } else if (server_reflexive_address_ == ACE_INET_Addr()) {
     server_reflexive_address_ = server_reflexive_address;
     return SRSM_Set;
   } else {
     server_reflexive_address_ = server_reflexive_address;
     return SRSM_Change;
   }
 }

◆ unset_stun_server_address()

const ACE_INET_Addr& OpenDDS::ICE::ServerReflexiveStateMachine::unset_stun_server_address ( ) const

inline

Definition at line 238 of file RTPS/ICE/Ice.h.

Referenced by OpenDDS::DCPS::RtpsUdpTransport::process_relay_sra(), and OpenDDS::RTPS::Spdp::SpdpTransport::process_relay_sra().

238 { return unset_stun_server_address_; }

OpenDDS::ICE::ServerReflexiveStateMachine::unset_stun_server_address_

ACE_INET_Addr unset_stun_server_address_

Definition: RTPS/ICE/Ice.h:275

Member Data Documentation

◆ latency_

DCPS::TimeDuration OpenDDS::ICE::ServerReflexiveStateMachine::latency_

private

Definition at line 280 of file RTPS/ICE/Ice.h.

◆ latency_available_

bool OpenDDS::ICE::ServerReflexiveStateMachine::latency_available_

private

Definition at line 281 of file RTPS/ICE/Ice.h.

◆ message_

STUN::Message OpenDDS::ICE::ServerReflexiveStateMachine::message_

private

Definition at line 274 of file RTPS/ICE/Ice.h.

◆ message_class_

STUN::Class OpenDDS::ICE::ServerReflexiveStateMachine::message_class_

private

Definition at line 273 of file RTPS/ICE/Ice.h.

◆ send_count_

size_t OpenDDS::ICE::ServerReflexiveStateMachine::send_count_

private

Definition at line 278 of file RTPS/ICE/Ice.h.

◆ server_reflexive_address_

ACE_INET_Addr OpenDDS::ICE::ServerReflexiveStateMachine::server_reflexive_address_

private

Definition at line 277 of file RTPS/ICE/Ice.h.

◆ stun_server_address_

ACE_INET_Addr OpenDDS::ICE::ServerReflexiveStateMachine::stun_server_address_

private

Definition at line 276 of file RTPS/ICE/Ice.h.

◆ timestamp_

DCPS::MonotonicTimePoint OpenDDS::ICE::ServerReflexiveStateMachine::timestamp_

private

Definition at line 279 of file RTPS/ICE/Ice.h.

◆ unset_stun_server_address_

ACE_INET_Addr OpenDDS::ICE::ServerReflexiveStateMachine::unset_stun_server_address_

private

Definition at line 275 of file RTPS/ICE/Ice.h.

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ StateChange

Constructor & Destructor Documentation

◆ ServerReflexiveStateMachine()

Member Function Documentation

◆ connected()

◆ error_response()

◆ is_response()

◆ latency()

◆ latency_available() [1/2]

◆ latency_available() [2/2]

◆ message()

◆ next_send()

◆ receive()

◆ send()

◆ start()

◆ stop()

◆ stun_server_address()

◆ success_response()

◆ unset_stun_server_address()

Member Data Documentation

◆ latency_

◆ latency_available_

◆ message_

◆ message_class_

◆ send_count_

◆ server_reflexive_address_

◆ stun_server_address_

◆ timestamp_

◆ unset_stun_server_address_