#include <EndpointManager.h>

Inheritance diagram for OpenDDS::ICE::EndpointManager:

Collaboration diagram for OpenDDS::ICE::EndpointManager:

[legend]

Classes
struct	ChangePasswordTask

struct	ServerReflexiveTask

Public Types
typedef std::set< std::string >	FoundationSet

Public Member Functions
	EndpointManager (AgentImpl *a_agent_impl, DCPS::WeakRcHandle< Endpoint > a_endpoint)

const AgentInfo &	agent_info () const

const FoundationSet &	foundations () const

void	add_agent_info_listener (const DCPS::GUID_t &a_local_guid, DCPS::WeakRcHandle< AgentInfoListener > a_agent_info_listener)

void	remove_agent_info_listener (const DCPS::GUID_t &a_local_guid)

void	start_ice (const DCPS::GUID_t &a_local_guid, const DCPS::GUID_t &a_remote_guid, const AgentInfo &a_remote_agent_info)

void	stop_ice (const DCPS::GUID_t &local_guid, const DCPS::GUID_t &remote_guid)

ACE_INET_Addr	get_address (const DCPS::GUID_t &a_local_guid, const DCPS::GUID_t &a_remote_guid) const

void	receive (const ACE_INET_Addr &a_local_address, const ACE_INET_Addr &a_remote_address, const STUN::Message &a_message)

void	set_responsible_checklist (const STUN::TransactionId &a_transaction_id, ChecklistPtr a_checklist)

void	unset_responsible_checklist (const STUN::TransactionId &a_transaction_id, ChecklistPtr a_checklist)

void	set_responsible_checklist (const GuidPair &a_guid_pair, ChecklistPtr a_checklist)

void	unset_responsible_checklist (const GuidPair &a_guid_pair, ChecklistPtr a_checklist)

void	set_responsible_checklist (const std::string &a_username, ChecklistPtr a_checklist)

void	unset_responsible_checklist (const std::string &a_username, ChecklistPtr a_checklist)

void	unfreeze ()

void	unfreeze (const FoundationType &a_foundation)

void	compute_active_foundations (ActiveFoundationSet &a_active_foundations) const

void	check_invariants () const

void	ice_connect (const GuidSetType &guids, const ACE_INET_Addr &addr)

void	ice_disconnect (const GuidSetType &guids, const ACE_INET_Addr &addr)

void	network_change ()

void	send (const ACE_INET_Addr &address, const STUN::Message &message)

void	purge ()

Public Member Functions inherited from OpenDDS::DCPS::RcObject
virtual	~RcObject ()

virtual void	_add_ref ()

virtual void	_remove_ref ()

long	ref_count () const

WeakObject *	_get_weak_object () const

Public Attributes
AgentImpl *const	agent_impl

DCPS::WeakRcHandle< Endpoint > const	endpoint

Private Types
typedef std::deque< DeferredTriggeredCheck >	DeferredTriggeredCheckListType

typedef std::map< std::string, DeferredTriggeredCheckListType >	DeferredTriggeredChecksType

typedef std::map< std::string, ChecklistPtr >	UsernameToChecklistType

typedef std::map< STUN::TransactionId, ChecklistPtr >	TransactionIdToChecklistType

typedef std::map< GuidPair, ChecklistPtr >	GuidPairToChecklistType

typedef std::map< DCPS::GUID_t, DCPS::WeakRcHandle< AgentInfoListener >, DCPS::GUID_tKeyLessThan >	AgentInfoListenersType

Private Member Functions
void	change_username ()

void	change_password (bool password_only)

void	set_host_addresses (const AddressListType &a_host_addresses)

void	set_server_reflexive_address (const ACE_INET_Addr &a_server_reflexive_address, const ACE_INET_Addr &a_stun_server_address)

void	regenerate_agent_info (bool password_only)

void	server_reflexive_task (const DCPS::MonotonicTimePoint &a_now)

bool	success_response (const STUN::Message &a_message)

bool	error_response (const STUN::Message &a_message)

ChecklistPtr	create_checklist (const AgentInfo &a_remote_agent_info)

STUN::Message	make_unknown_attributes_error_response (const STUN::Message &a_message, const std::vector< STUN::AttributeType > &a_unknown_attributes)

STUN::Message	make_bad_request_error_response (const STUN::Message &a_message, const std::string &a_reason)

STUN::Message	make_unauthorized_error_response (const STUN::Message &a_message)

void	request (const ACE_INET_Addr &a_local_address, const ACE_INET_Addr &a_remote_address, const STUN::Message &a_message)

void	indication (const ACE_INET_Addr &a_local_address, const ACE_INET_Addr &a_remote_address, const STUN::Message &a_message)

void	success_response (const ACE_INET_Addr &a_local_address, const ACE_INET_Addr &a_remote_address, const STUN::Message &a_message)

void	error_response (const ACE_INET_Addr &a_local_address, const ACE_INET_Addr &a_remote_address, const STUN::Message &a_message)

Additional Inherited Members
Protected Member Functions inherited from OpenDDS::DCPS::RcObject
	RcObject ()

Detailed Description

Definition at line 51 of file EndpointManager.h.

Member Typedef Documentation

◆ AgentInfoListenersType

typedef std::map<DCPS::GUID_t, DCPS::WeakRcHandle<AgentInfoListener>, DCPS::GUID_tKeyLessThan> OpenDDS::ICE::EndpointManager::AgentInfoListenersType

private

Definition at line 198 of file EndpointManager.h.

◆ DeferredTriggeredCheckListType

typedef std::deque<DeferredTriggeredCheck> OpenDDS::ICE::EndpointManager::DeferredTriggeredCheckListType

private

Definition at line 182 of file EndpointManager.h.

◆ DeferredTriggeredChecksType

typedef std::map<std::string, DeferredTriggeredCheckListType> OpenDDS::ICE::EndpointManager::DeferredTriggeredChecksType

private

Definition at line 183 of file EndpointManager.h.

◆ FoundationSet

typedef std::set<std::string> OpenDDS::ICE::EndpointManager::FoundationSet

Definition at line 62 of file EndpointManager.h.

◆ GuidPairToChecklistType

typedef std::map<GuidPair, ChecklistPtr> OpenDDS::ICE::EndpointManager::GuidPairToChecklistType

private

Definition at line 195 of file EndpointManager.h.

◆ TransactionIdToChecklistType

typedef std::map<STUN::TransactionId, ChecklistPtr> OpenDDS::ICE::EndpointManager::TransactionIdToChecklistType

private

Definition at line 191 of file EndpointManager.h.

◆ UsernameToChecklistType

typedef std::map<std::string, ChecklistPtr> OpenDDS::ICE::EndpointManager::UsernameToChecklistType

private

Definition at line 187 of file EndpointManager.h.

Constructor & Destructor Documentation

◆ EndpointManager()

OpenDDS::ICE::EndpointManager::EndpointManager	(	AgentImpl *	a_agent_impl,
		DCPS::WeakRcHandle< Endpoint >	a_endpoint
	)

Definition at line 28 of file EndpointManager.cpp.

References agent_info_, binding_request_, change_username(), OpenDDS::STUN::Message::clear_transaction_id(), endpoint, OpenDDS::ICE::FULL, ice_tie_breaker_, OpenDDS::DCPS::WeakRcHandle< T >::lock(), set_host_addresses(), TheSecurityRegistry, and OpenDDS::ICE::AgentInfo::type.

                                                                                                :
   agent_impl(a_agent_impl),
   endpoint(a_endpoint),
   requesting_(true),
   send_count_(0),
   server_reflexive_task_(DCPS::make_rch<ServerReflexiveTask>(rchandle_from(this))),
   change_password_task_(DCPS::make_rch<ChangePasswordTask>(rchandle_from(this)))
 {
 
   binding_request_.clear_transaction_id();
 
   // Set the type.
   agent_info_.type = FULL;
 
   TheSecurityRegistry->builtin_config()->get_utility()->generate_random_bytes(&ice_tie_breaker_, sizeof(ice_tie_breaker_));
 
   change_username();
   DCPS::RcHandle<Endpoint> e = endpoint.lock();
   if (e) {
     set_host_addresses(e->host_addresses());
   }
 }

Member Function Documentation

◆ add_agent_info_listener()

void OpenDDS::ICE::EndpointManager::add_agent_info_listener	(	const DCPS::GUID_t &	a_local_guid,
		DCPS::WeakRcHandle< AgentInfoListener >	a_agent_info_listener
	)

inline

Definition at line 68 of file EndpointManager.h.

   {
     agent_info_listeners_[a_local_guid] = a_agent_info_listener;
   }

◆ agent_info()

const AgentInfo& OpenDDS::ICE::EndpointManager::agent_info ( ) const

inline

Definition at line 57 of file EndpointManager.h.

Referenced by regenerate_agent_info().

   {
     return agent_info_;
   }

◆ change_password()

void OpenDDS::ICE::EndpointManager::change_password ( bool password_only )

private

Definition at line 176 of file EndpointManager.cpp.

References agent_info_, guid_pair_to_checklist_, OpenDDS::ICE::AgentInfo::password, regenerate_agent_info(), TheSecurityRegistry, and OpenDDS::DCPS::to_hex_dds_string().

Referenced by change_username().

 {
   if (password_only && guid_pair_to_checklist_.empty()) {
     return;
   }
 
   unsigned char password[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
   TheSecurityRegistry->builtin_config()->get_utility()->generate_random_bytes(password, sizeof(password));
   agent_info_.password = OpenDDS::DCPS::to_hex_dds_string(password, 16, 0, 0);
   regenerate_agent_info(password_only);
 }

◆ change_username()

void OpenDDS::ICE::EndpointManager::change_username ( )

private

Definition at line 167 of file EndpointManager.cpp.

References agent_info_, change_password(), TheSecurityRegistry, OpenDDS::DCPS::to_hex_dds_string(), and OpenDDS::ICE::AgentInfo::username.

Referenced by EndpointManager(), and start_ice().

 {
   // Generate the username.
   unsigned char username[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
   TheSecurityRegistry->builtin_config()->get_utility()->generate_random_bytes(username, sizeof(username));
   agent_info_.username = OpenDDS::DCPS::to_hex_dds_string(username, 16, 0, 0);
   change_password(false);
 }

◆ check_invariants()

void OpenDDS::ICE::EndpointManager::check_invariants ( ) const

Definition at line 735 of file EndpointManager.cpp.

References deferred_triggered_checks_, guid_pair_to_checklist_, OpenDDS::ICE::Configuration::instance(), OPENDDS_ASSERT, OpenDDS::ICE::Configuration::server_reflexive_address_period(), transaction_id_to_checklist_, and username_to_checklist_.

 {
   // Check for expired deferred checks.
   for (DeferredTriggeredChecksType::const_iterator pos = deferred_triggered_checks_.begin(),
          limit = deferred_triggered_checks_.end(); pos != limit; ++pos) {
     const DeferredTriggeredCheckListType& list = pos->second;
     ACE_UNUSED_ARG(list);
     OPENDDS_ASSERT(!list.empty());
     OPENDDS_ASSERT(list.front().expiration_date >= MonotonicTimePoint::now() - ICE::Configuration::instance()->server_reflexive_address_period() - ICE::Configuration::instance()->server_reflexive_address_period());
   }
 
   for (UsernameToChecklistType::const_iterator pos = username_to_checklist_.begin(),
          limit = username_to_checklist_.end(); pos != limit; ++pos) {
     ChecklistPtr checklist = pos->second;
     OPENDDS_ASSERT(checklist->original_remote_agent_info().username == pos->first);
     checklist->check_invariants();
   }
 
   for (TransactionIdToChecklistType::const_iterator pos = transaction_id_to_checklist_.begin(),
          limit = transaction_id_to_checklist_.end(); pos != limit; ++pos) {
     ChecklistPtr checklist = pos->second;
     ACE_UNUSED_ARG(checklist);
     OPENDDS_ASSERT(checklist->has_transaction_id(pos->first));
   }
 
   for (GuidPairToChecklistType::const_iterator pos = guid_pair_to_checklist_.begin(),
          limit = guid_pair_to_checklist_.end(); pos != limit; ++pos) {
     ChecklistPtr checklist = pos->second;
     ACE_UNUSED_ARG(checklist);
     OPENDDS_ASSERT(checklist->has_guid_pair(pos->first));
   }
 }

◆ compute_active_foundations()

void OpenDDS::ICE::EndpointManager::compute_active_foundations ( ActiveFoundationSet & a_active_foundations ) const

Definition at line 726 of file EndpointManager.cpp.

References username_to_checklist_.

 {
   for (UsernameToChecklistType::const_iterator pos = username_to_checklist_.begin(),
        limit = username_to_checklist_.end(); pos != limit; ++pos) {
     ChecklistPtr checklist = pos->second;
     checklist->compute_active_foundations(a_active_foundations);
   }
 }

◆ create_checklist()

ChecklistPtr OpenDDS::ICE::EndpointManager::create_checklist ( const AgentInfo & a_remote_agent_info )

private

Definition at line 406 of file EndpointManager.cpp.

References agent_info_, deferred_triggered_checks_, ice_tie_breaker_, OpenDDS::DCPS::ref(), and OpenDDS::ICE::AgentInfo::username.

Referenced by regenerate_agent_info(), and start_ice().

 {
   ChecklistPtr checklist = DCPS::make_rch<Checklist>(this, DCPS::ref(agent_info_), DCPS::ref(remote_agent_info), ice_tie_breaker_);
   // Add the deferred triggered first in case there was a nominating check.
   DeferredTriggeredChecksType::iterator pos = deferred_triggered_checks_.find(remote_agent_info.username);
 
   if (pos != deferred_triggered_checks_.end()) {
     const DeferredTriggeredCheckListType& list = pos->second;
 
     for (DeferredTriggeredCheckListType::const_iterator pos2 = list.begin(), limit2 = list.end(); pos2 != limit2; ++pos2) {
       checklist->generate_triggered_check(pos2->local_address, pos2->remote_address, pos2->priority, pos2->use_candidate);
     }
 
     deferred_triggered_checks_.erase(pos);
   }
 
   checklist->unfreeze();
 
   return checklist;
 }

◆ error_response() [1/2]

bool OpenDDS::ICE::EndpointManager::error_response ( const STUN::Message & a_message )

private

Definition at line 380 of file EndpointManager.cpp.

References ACE_ERROR, ACE_TEXT(), binding_request_, 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::transaction_id, and OpenDDS::STUN::UNKNOWN_ATTRIBUTE.

Referenced by error_response(), and receive().

 {
   if (a_message.transaction_id != binding_request_.transaction_id) {
     return false;
   }
 
   if (a_message.has_error_code()) {
     ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) EndpointManager::error_response: WARNING STUN error response code=%d reason=%s\n"), a_message.get_error_code(), a_message.get_error_reason().c_str()));
 
     if (a_message.get_error_code() == STUN::UNKNOWN_ATTRIBUTE && a_message.has_unknown_attributes()) {
       std::vector<STUN::AttributeType> unknown_attributes = a_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) EndpointManager::error_response: WARNING Unknown STUN attribute %d\n"), *pos));
       }
     }
   }
 
   else {
     ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) EndpointManager::error_response: WARNING STUN error response (no code)\n")));
   }
 
   return true;
 }

◆ error_response() [2/2]

void OpenDDS::ICE::EndpointManager::error_response	(	const ACE_INET_Addr &	a_local_address,
		const ACE_INET_Addr &	a_remote_address,
		const STUN::Message &	a_message
	)

private

Definition at line 696 of file EndpointManager.cpp.

References ACE_ERROR, ACE_TEXT(), OpenDDS::STUN::BINDING, error_response(), LM_WARNING, OpenDDS::STUN::Message::method, OpenDDS::STUN::Message::transaction_id, and transaction_id_to_checklist_.

 {
   switch (a_message.method) {
   case STUN::BINDING: {
     if (error_response(a_message)) {
       return;
     }
 
     TransactionIdToChecklistType::const_iterator pos = transaction_id_to_checklist_.find(a_message.transaction_id);
 
     if (pos == transaction_id_to_checklist_.end()) {
       // Probably a check that got cancelled.
       return;
     }
 
     // Checklist is responsible for updating the map.
     // Checklist also checks for required parameters.
     pos->second->error_response(a_local_address, a_remote_address, a_message);
   }
   break;
 
   default:
     // Unknown method.  Stop processing.
     ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) EndpointManager::error_response: WARNING Unknown STUN method\n")));
     break;
   }
 }

◆ foundations()

const FoundationSet& OpenDDS::ICE::EndpointManager::foundations ( ) const

inline

Definition at line 63 of file EndpointManager.h.

Referenced by OpenDDS::ICE::Checklist::unfreeze().

   {
     return foundations_;
   }

◆ get_address()

ACE_INET_Addr OpenDDS::ICE::EndpointManager::get_address	(	const DCPS::GUID_t &	a_local_guid,
		const DCPS::GUID_t &	a_remote_guid
	)		const

Definition at line 129 of file EndpointManager.cpp.

References guid_pair_to_checklist_.

 {
   GuidPair guidp(a_local_guid, a_remote_guid);
   GuidPairToChecklistType::const_iterator pos = guid_pair_to_checklist_.find(guidp);
 
   if (pos != guid_pair_to_checklist_.end()) {
     return pos->second->selected_address();
   }
 
   return ACE_INET_Addr();
 }

◆ ice_connect()

void OpenDDS::ICE::EndpointManager::ice_connect	(	const GuidSetType &	guids,
		const ACE_INET_Addr &	addr
	)

inline

Definition at line 146 of file EndpointManager.h.

References OpenDDS::DCPS::WeakRcHandle< T >::lock().

Referenced by OpenDDS::ICE::Checklist::execute(), and OpenDDS::ICE::Checklist::succeeded().

   {
     DCPS::RcHandle<Endpoint> e = endpoint.lock();
     if (e) {
       e->ice_connect(guids, addr);
     }
   }

◆ ice_disconnect()

void OpenDDS::ICE::EndpointManager::ice_disconnect	(	const GuidSetType &	guids,
		const ACE_INET_Addr &	addr
	)

inline

Definition at line 154 of file EndpointManager.h.

References OpenDDS::DCPS::WeakRcHandle< T >::lock(), and send().

Referenced by OpenDDS::ICE::Checklist::execute().

   {
     DCPS::RcHandle<Endpoint> e = endpoint.lock();
     if (e) {
       e->ice_disconnect(guids, addr);
     }
   }

◆ indication()

void OpenDDS::ICE::EndpointManager::indication	(	const ACE_INET_Addr &	a_local_address,
		const ACE_INET_Addr &	a_remote_address,
		const STUN::Message &	a_message
	)

private

Definition at line 599 of file EndpointManager.cpp.

References ACE_ERROR, ACE_TEXT(), agent_info_, OpenDDS::STUN::BINDING, OpenDDS::STUN::Message::get_username(), OpenDDS::STUN::Message::has_fingerprint(), OpenDDS::STUN::Message::has_message_integrity(), LM_WARNING, OpenDDS::STUN::Message::method, OpenDDS::ICE::AgentInfo::password, OpenDDS::STUN::Message::unknown_comprehension_required_attributes(), OpenDDS::ICE::AgentInfo::username, username_to_checklist_, and OpenDDS::STUN::Message::verify_message_integrity().

Referenced by receive().

 {
   std::string username;
 
   if (!a_message.get_username(username)) {
     ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) EndpointManager::indication: WARNING No USERNAME attribute\n")));
     return;
   }
 
   if (!a_message.has_message_integrity()) {
     ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) EndpointManager::indication: WARNING No MESSAGE_INTEGRITY attribute\n")));
     return;
   }
 
   size_t idx = username.find(':');
 
   if (idx == std::string::npos) {
     ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) EndpointManager::indication: WARNING USERNAME does not contain a colon\n")));
     return;
   }
 
   if (username.substr(0, idx) != agent_info_.username) {
     // We expect this to happen.
     return;
   }
 
   const std::string remote_username = username.substr(++idx);
 
   // Check the message_integrity.
   if (!a_message.verify_message_integrity(agent_info_.password)) {
     // We expect this to happen.
     return;
   }
 
   std::vector<STUN::AttributeType> unknown_attributes = a_message.unknown_comprehension_required_attributes();
 
   if (!unknown_attributes.empty()) {
     ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) EndpointManager::indication: WARNING Unknown comprehension required attributes\n")));
     return;
   }
 
   if (!a_message.has_fingerprint()) {
     ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) EndpointManager::indication: WARNING No FINGERPRINT attribute\n")));
     return;
   }
 
   switch (a_message.method) {
   case STUN::BINDING: {
     // Section 11
     UsernameToChecklistType::const_iterator pos = username_to_checklist_.find(remote_username);
 
     if (pos != username_to_checklist_.end()) {
       // We have a checklist.
       pos->second->indication();
     }
   }
   break;
 
   default:
     // Unknown method.  Stop processing.
     ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) EndpointManager::indication: WARNING Unknown STUN method\n")));
     break;
   }
 }

◆ make_bad_request_error_response()

STUN::Message OpenDDS::ICE::EndpointManager::make_bad_request_error_response	(	const STUN::Message &	a_message,
		const std::string &	a_reason
	)

private

Definition at line 442 of file EndpointManager.cpp.

References agent_info_, OpenDDS::STUN::Message::append_attribute(), OpenDDS::STUN::BAD_REQUEST, OpenDDS::STUN::Message::class_, OpenDDS::STUN::TransactionId::data, OpenDDS::STUN::ERROR_RESPONSE, OpenDDS::STUN::make_error_code(), OpenDDS::STUN::make_fingerprint(), OpenDDS::STUN::make_message_integrity(), memcpy(), OpenDDS::STUN::Message::method, OpenDDS::ICE::AgentInfo::password, OpenDDS::STUN::Message::password, and OpenDDS::STUN::Message::transaction_id.

Referenced by request().

 {
   STUN::Message response;
   response.class_ = STUN::ERROR_RESPONSE;
   response.method = a_message.method;
   memcpy(response.transaction_id.data, a_message.transaction_id.data, sizeof(a_message.transaction_id.data));
   response.append_attribute(STUN::make_error_code(STUN::BAD_REQUEST, a_reason));
   response.append_attribute(STUN::make_message_integrity());
   response.password = agent_info_.password;
   response.append_attribute(STUN::make_fingerprint());
   return response;
 }

◆ make_unauthorized_error_response()

STUN::Message OpenDDS::ICE::EndpointManager::make_unauthorized_error_response ( const STUN::Message & a_message )

private

Definition at line 456 of file EndpointManager.cpp.

References agent_info_, OpenDDS::STUN::Message::append_attribute(), OpenDDS::STUN::Message::class_, OpenDDS::STUN::TransactionId::data, OpenDDS::STUN::ERROR_RESPONSE, OpenDDS::STUN::make_error_code(), OpenDDS::STUN::make_fingerprint(), OpenDDS::STUN::make_message_integrity(), memcpy(), OpenDDS::STUN::Message::method, OpenDDS::ICE::AgentInfo::password, OpenDDS::STUN::Message::password, OpenDDS::STUN::Message::transaction_id, and OpenDDS::STUN::UNAUTHORIZED.

Referenced by request().

 {
   STUN::Message response;
   response.class_ = STUN::ERROR_RESPONSE;
   response.method = a_message.method;
   memcpy(response.transaction_id.data, a_message.transaction_id.data, sizeof(a_message.transaction_id.data));
   response.append_attribute(STUN::make_error_code(STUN::UNAUTHORIZED, "Unauthorized"));
   response.append_attribute(STUN::make_message_integrity());
   response.password = agent_info_.password;
   response.append_attribute(STUN::make_fingerprint());
   return response;
 }

◆ make_unknown_attributes_error_response()

STUN::Message OpenDDS::ICE::EndpointManager::make_unknown_attributes_error_response	(	const STUN::Message &	a_message,
		const std::vector< STUN::AttributeType > &	a_unknown_attributes
	)

private

Definition at line 427 of file EndpointManager.cpp.

References agent_info_, OpenDDS::STUN::Message::append_attribute(), OpenDDS::STUN::Message::class_, OpenDDS::STUN::TransactionId::data, OpenDDS::STUN::ERROR_RESPONSE, OpenDDS::STUN::make_error_code(), OpenDDS::STUN::make_fingerprint(), OpenDDS::STUN::make_message_integrity(), OpenDDS::STUN::make_unknown_attributes(), memcpy(), OpenDDS::STUN::Message::method, OpenDDS::ICE::AgentInfo::password, OpenDDS::STUN::Message::password, OpenDDS::STUN::Message::transaction_id, and OpenDDS::STUN::UNKNOWN_ATTRIBUTE.

Referenced by request().

 {
   STUN::Message response;
   response.class_ = STUN::ERROR_RESPONSE;
   response.method = a_message.method;
   memcpy(response.transaction_id.data, a_message.transaction_id.data, sizeof(a_message.transaction_id.data));
   response.append_attribute(STUN::make_error_code(STUN::UNKNOWN_ATTRIBUTE, "Unknown Attributes"));
   response.append_attribute(STUN::make_unknown_attributes(a_unknown_attributes));
   response.append_attribute(STUN::make_message_integrity());
   response.password = agent_info_.password;
   response.append_attribute(STUN::make_fingerprint());
   return response;
 }

◆ network_change()

void OpenDDS::ICE::EndpointManager::network_change ( )

Definition at line 816 of file EndpointManager.cpp.

References endpoint, OpenDDS::DCPS::WeakRcHandle< T >::lock(), and set_host_addresses().

 {
   DCPS::RcHandle<Endpoint> e = endpoint.lock();
   if (e) {
     set_host_addresses(e->host_addresses());
   }
 }

◆ purge()

void OpenDDS::ICE::EndpointManager::purge ( void )

Definition at line 832 of file EndpointManager.cpp.

References agent_info_listeners_, OPENDDS_END_VERSIONED_NAMESPACE_DECL, and username_to_checklist_.

 {
   UsernameToChecklistType checklists = username_to_checklist_;
   for (UsernameToChecklistType::const_iterator pos = checklists.begin(), limit = checklists.end(); pos != limit; ++pos) {
     pos->second->remove_guids();
   }
 
   for (AgentInfoListenersType::const_iterator pos = agent_info_listeners_.begin(), limit = agent_info_listeners_.end(); pos != limit; ++pos) {
     DCPS::RcHandle<AgentInfoListener> ail = pos->second.lock();
     if (ail) {
       ail->remove_agent_info(pos->first);
     }
   }
 }

◆ receive()

void OpenDDS::ICE::EndpointManager::receive	(	const ACE_INET_Addr &	a_local_address,
		const ACE_INET_Addr &	a_remote_address,
		const STUN::Message &	a_message
	)

Definition at line 142 of file EndpointManager.cpp.

References ACE_ERROR, ACE_TEXT(), OpenDDS::STUN::Message::class_, OpenDDS::STUN::ERROR_RESPONSE, error_response(), OpenDDS::STUN::INDICATION, indication(), LM_WARNING, OpenDDS::STUN::REQUEST, request(), OpenDDS::STUN::SUCCESS_RESPONSE, and success_response().

 {
   switch (a_message.class_) {
   case STUN::REQUEST:
     request(a_local_address, a_remote_address, a_message);
     return;
 
   case STUN::INDICATION:
     indication(a_local_address, a_remote_address, a_message);
     return;
 
   case STUN::SUCCESS_RESPONSE:
     success_response(a_local_address, a_remote_address, a_message);
     return;
 
   case STUN::ERROR_RESPONSE:
     error_response(a_local_address, a_remote_address, a_message);
     return;
   }
 
   ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) EndpointManager::receive: WARNING Unknown STUN message class %d\n"), a_message.class_));
 }

◆ regenerate_agent_info()

void OpenDDS::ICE::EndpointManager::regenerate_agent_info ( bool password_only )

private

Definition at line 238 of file EndpointManager.cpp.

References ACE_GUARD, agent_impl, agent_info(), agent_info_, agent_info_listeners_, OpenDDS::ICE::AgentInfo::candidates, OpenDDS::ICE::candidates_equal(), OpenDDS::ICE::candidates_sorted(), create_checklist(), foundations_, host_addresses_, OpenDDS::ICE::make_host_candidate(), OpenDDS::ICE::make_server_reflexive_candidate(), OpenDDS::ICE::AgentImpl::mutex, server_reflexive_address_, stun_server_address_, and username_to_checklist_.

Referenced by change_password(), set_host_addresses(), and set_server_reflexive_address().

 {
   if (!password_only) {
     // Populate candidates.
     agent_info_.candidates.clear();
 
     for (AddressListType::const_iterator pos = host_addresses_.begin(), limit = host_addresses_.end(); pos != limit; ++pos) {
       agent_info_.candidates.push_back(make_host_candidate(*pos));
 
       if (server_reflexive_address_ != ACE_INET_Addr() &&
           stun_server_address_ != ACE_INET_Addr()) {
         agent_info_.candidates.push_back(make_server_reflexive_candidate(server_reflexive_address_, *pos, stun_server_address_));
       }
     }
 
     // Eliminate duplicates.
     std::sort(agent_info_.candidates.begin(), agent_info_.candidates.end(), candidates_sorted);
     AgentInfo::CandidatesType::iterator last = std::unique(agent_info_.candidates.begin(), agent_info_.candidates.end(), candidates_equal);
     agent_info_.candidates.erase(last, agent_info_.candidates.end());
 
     foundations_.clear();
     for (AgentInfo::CandidatesType::const_iterator pos = agent_info_.candidates.begin(), limit = agent_info_.candidates.end(); pos != limit; ++pos) {
       foundations_.insert(pos->foundation);
     }
 
     // Start over.
     UsernameToChecklistType old_checklists = username_to_checklist_;
 
     for (UsernameToChecklistType::const_iterator pos = old_checklists.begin(),
          limit = old_checklists.end();
          pos != limit; ++pos) {
       ChecklistPtr old_checklist = pos->second;
       AgentInfo const remote_agent_info = old_checklist->original_remote_agent_info();
       GuidSetType const guids = old_checklist->guids();
       old_checklist->remove_guids();
       ChecklistPtr new_checklist = create_checklist(remote_agent_info);
       new_checklist->add_guids(guids);
     }
   }
 
   {
     // Propagate changed agent info.
 
     // Make a copy.
     AgentInfoListenersType agent_info_listeners = agent_info_listeners_;
     AgentInfo agent_info = agent_info_;
 
     // Release the lock.
     ACE_Reverse_Lock<ACE_Recursive_Thread_Mutex> rev_lock(agent_impl->mutex);
     ACE_GUARD(ACE_Reverse_Lock<ACE_Recursive_Thread_Mutex>, rev_guard, rev_lock);
 
     for (AgentInfoListenersType::const_iterator pos = agent_info_listeners.begin(),
          limit =  agent_info_listeners.end(); pos != limit; ++pos) {
       DCPS::RcHandle<AgentInfoListener> ail = pos->second.lock();
       if (ail) {
         ail->update_agent_info(pos->first, agent_info);
       }
     }
   }
 }

◆ remove_agent_info_listener()

void OpenDDS::ICE::EndpointManager::remove_agent_info_listener ( const DCPS::GUID_t & a_local_guid )

inline

Definition at line 74 of file EndpointManager.h.

   {
     agent_info_listeners_.erase(a_local_guid);
   }

◆ request()

void OpenDDS::ICE::EndpointManager::request	(	const ACE_INET_Addr &	a_local_address,
		const ACE_INET_Addr &	a_remote_address,
		const STUN::Message &	a_message
	)

private

Definition at line 470 of file EndpointManager.cpp.

Referenced by receive().

 {
   std::string username;
 
   if (!a_message.get_username(username)) {
     ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) EndpointManager::request: WARNING No USERNAME attribute\n")));
     send(a_remote_address,
          make_bad_request_error_response(a_message, "Bad Request: USERNAME must be present"));
     return;
   }
 
   if (!a_message.has_message_integrity()) {
     ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) EndpointManager::request: WARNING No MESSAGE_INTEGRITY attribute\n")));
     send(a_remote_address,
          make_bad_request_error_response(a_message, "Bad Request: MESSAGE_INTEGRITY must be present"));
     return;
   }
 
   size_t idx = username.find(':');
 
   if (idx == std::string::npos) {
     ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) EndpointManager::request: WARNING USERNAME does not contain a colon\n")));
     send(a_remote_address,
          make_bad_request_error_response(a_message, "Bad Request: USERNAME must be colon-separated"));
     return;
   }
 
   if (username.substr(0, idx) != agent_info_.username) {
     // We expect this to happen.
     send(a_remote_address,
          make_unauthorized_error_response(a_message));
     return;
   }
 
   const std::string remote_username = username.substr(++idx);
 
   // Check the message_integrity.
   if (!a_message.verify_message_integrity(agent_info_.password)) {
     // We expect this to happen.
     send(a_remote_address,
          make_unauthorized_error_response(a_message));
     return;
   }
 
   std::vector<STUN::AttributeType> unknown_attributes = a_message.unknown_comprehension_required_attributes();
 
   if (!unknown_attributes.empty()) {
     ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) EndpointManager::request: WARNING Unknown comprehension required attributes\n")));
     send(a_remote_address,
          make_unknown_attributes_error_response(a_message, unknown_attributes));
     return;
   }
 
   if (!a_message.has_fingerprint()) {
     ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) EndpointManager::request: WARNING No FINGERPRINT attribute\n")));
     send(a_remote_address,
          make_bad_request_error_response(a_message, "Bad Request: FINGERPRINT must be present"));
     return;
   }
 
   if (!a_message.has_ice_controlled() && !a_message.has_ice_controlling()) {
     ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) EndpointManager::request: WARNING No ICE_CONTROLLED/ICE_CONTROLLING attribute\n")));
     send(a_remote_address,
          make_bad_request_error_response(a_message, "Bad Request: Either ICE_CONTROLLED or ICE_CONTROLLING must be present"));
     return;
   }
 
   bool use_candidate = a_message.has_use_candidate();
 
   if (use_candidate && a_message.has_ice_controlled()) {
     ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) EndpointManager::request: WARNING USE_CANDIDATE without ICE_CONTROLLED\n")));
     send(a_remote_address,
          make_bad_request_error_response(a_message, "Bad Request: USE_CANDIDATE can only be present when ICE_CONTROLLED is present"));
     return;
   }
 
   ACE_UINT32 priority;
 
   if (!a_message.get_priority(priority)) {
     ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) EndpointManager::request: WARNING No PRIORITY attribute\n")));
     send(a_remote_address,
          make_bad_request_error_response(a_message, "Bad Request: PRIORITY must be present"));
     return;
   }
 
   switch (a_message.method) {
   case STUN::BINDING: {
     // 7.3
     STUN::Message response;
     response.class_ = STUN::SUCCESS_RESPONSE;
     response.method = STUN::BINDING;
     memcpy(response.transaction_id.data, a_message.transaction_id.data, sizeof(a_message.transaction_id.data));
     response.append_attribute(STUN::make_mapped_address(a_remote_address));
     response.append_attribute(STUN::make_xor_mapped_address(a_remote_address));
     response.append_attribute(STUN::make_message_integrity());
     response.password = agent_info_.password;
     response.append_attribute(STUN::make_fingerprint());
     send(a_remote_address, response);
 
     // 7.3.1.3
     UsernameToChecklistType::const_iterator pos = username_to_checklist_.find(remote_username);
 
     if (pos != username_to_checklist_.end()) {
       // We have a checklist.
       ChecklistPtr checklist = pos->second;
       checklist->generate_triggered_check(a_local_address, a_remote_address, priority, use_candidate);
     }
 
     else {
       std::pair<DeferredTriggeredChecksType::iterator, bool> x =
         deferred_triggered_checks_.insert(std::make_pair(remote_username, DeferredTriggeredCheckListType()));
       x.first->second.push_back(DeferredTriggeredCheck(
         a_local_address, a_remote_address, priority, use_candidate,
         MonotonicTimePoint::now() + ICE::Configuration::instance()->deferred_triggered_check_ttl()));
     }
   }
   break;
 
   default:
     // Unknown method.  Stop processing.
     ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) EndpointManager::request: WARNING Unknown STUN method\n")));
     send(a_remote_address,
          make_bad_request_error_response(a_message, "Bad Request: Unknown method"));
     break;
   }
 }

◆ send()

void OpenDDS::ICE::EndpointManager::send	(	const ACE_INET_Addr &	address,
		const STUN::Message &	message
	)

Definition at line 824 of file EndpointManager.cpp.

References endpoint, and OpenDDS::DCPS::WeakRcHandle< T >::lock().

Referenced by OpenDDS::ICE::Checklist::do_next_check(), OpenDDS::ICE::Checklist::execute(), request(), and server_reflexive_task().

 {
   DCPS::RcHandle<Endpoint> e = endpoint.lock();
   if (e) {
     e->send(address, message);
   }
 }

◆ server_reflexive_task()

void OpenDDS::ICE::EndpointManager::server_reflexive_task ( const DCPS::MonotonicTimePoint & a_now )

private

Definition at line 299 of file EndpointManager.cpp.

References OpenDDS::STUN::Message::append_attribute(), OpenDDS::STUN::BINDING, binding_request_, OpenDDS::STUN::Message::class_, deferred_triggered_checks_, endpoint, OpenDDS::STUN::Message::generate_transaction_id(), OpenDDS::STUN::INDICATION, OpenDDS::ICE::Configuration::instance(), OpenDDS::DCPS::WeakRcHandle< T >::lock(), OpenDDS::STUN::make_fingerprint(), OpenDDS::STUN::Message::method, next_stun_server_address_, OpenDDS::STUN::REQUEST, requesting_, send(), send_count_, OpenDDS::ICE::Configuration::server_reflexive_indication_count(), and set_host_addresses().

 {
   // Request and maintain a server-reflexive address.
   DCPS::RcHandle<Endpoint> e = endpoint.lock();
 
   if (e) {
     next_stun_server_address_ = e->stun_server_address();
   }
 
   if (next_stun_server_address_ != ACE_INET_Addr()) {
     binding_request_ = STUN::Message();
     binding_request_.class_ = requesting_ ? STUN::REQUEST : STUN::INDICATION;
     binding_request_.method = STUN::BINDING;
     binding_request_.generate_transaction_id();
     binding_request_.append_attribute(STUN::make_fingerprint());
 
     send(next_stun_server_address_, binding_request_);
 
     if (!requesting_ && send_count_ == ICE::Configuration::instance()->server_reflexive_indication_count() - 1) {
       requesting_ = true;
     }
 
     send_count_ = (send_count_ + 1) % ICE::Configuration::instance()->server_reflexive_indication_count();
   } else {
     requesting_ = true;
     send_count_ = 0;
   }
 
   // Remove expired deferred checks.
   for (DeferredTriggeredChecksType::iterator pos = deferred_triggered_checks_.begin(),
        limit = deferred_triggered_checks_.end(); pos != limit;) {
     DeferredTriggeredCheckListType& list = pos->second;
 
     while (!list.empty() && list.front().expiration_date < a_now) {
       list.pop_front();
     }
 
     if (list.empty()) {
       deferred_triggered_checks_.erase(pos++);
     } else {
       ++pos;
     }
   }
 
   // Repopulate the host addresses.
   if (e) {
     set_host_addresses(e->host_addresses());
   }
 }

◆ set_host_addresses()

void OpenDDS::ICE::EndpointManager::set_host_addresses ( const AddressListType & a_host_addresses )

private

Definition at line 188 of file EndpointManager.cpp.

References host_addresses_, OPENDDS_ASSERT, and regenerate_agent_info().

Referenced by EndpointManager(), network_change(), and server_reflexive_task().

 {
   // Section IETF RFC 8445 5.1.1.1
   AddressListType host_addresses;
 
   for (AddressListType::const_iterator pos = a_host_addresses.begin(), limit = a_host_addresses.end();
        pos != limit; ++pos) {
     OPENDDS_ASSERT(!pos->is_any());
 
     if (pos->is_loopback()) {
       continue;
     }
 
 #if ACE_HAS_IPV6
     if (pos->is_ipv4_compat_ipv6()) {
       continue;
     }
 
     // TODO(jrw972):  Include once supported in ACE.
     // if (pos->is_sitelocal()) {
     //   continue;
     // }
 
 #if !IPV6_V6ONLY
     if (pos->is_ipv4_mapped_ipv6()) {
       continue;
     }
 #endif
 #endif
 
     host_addresses.push_back(*pos);
   }
 
   if (host_addresses_ != host_addresses) {
     host_addresses_ = host_addresses;
     regenerate_agent_info(false);
   }
 }

◆ set_responsible_checklist() [1/3]

void OpenDDS::ICE::EndpointManager::set_responsible_checklist	(	const STUN::TransactionId &	a_transaction_id,
		ChecklistPtr	a_checklist
	)

inline

Definition at line 93 of file EndpointManager.h.

References OPENDDS_ASSERT.

Referenced by OpenDDS::ICE::Checklist::add_guid(), OpenDDS::ICE::Checklist::Checklist(), and OpenDDS::ICE::Checklist::do_next_check().

   {
     OPENDDS_ASSERT(!transaction_id_to_checklist_.count(a_transaction_id));
     transaction_id_to_checklist_[a_transaction_id] = a_checklist;
   }

◆ set_responsible_checklist() [2/3]

void OpenDDS::ICE::EndpointManager::set_responsible_checklist	(	const GuidPair &	a_guid_pair,
		ChecklistPtr	a_checklist
	)

inline

Definition at line 108 of file EndpointManager.h.

References OPENDDS_ASSERT.

   {
     OPENDDS_ASSERT(!guid_pair_to_checklist_.count(a_guid_pair));
     guid_pair_to_checklist_[a_guid_pair] = a_checklist;
   }

◆ set_responsible_checklist() [3/3]

void OpenDDS::ICE::EndpointManager::set_responsible_checklist	(	const std::string &	a_username,
		ChecklistPtr	a_checklist
	)

inline

Definition at line 123 of file EndpointManager.h.

References OPENDDS_ASSERT.

   {
     OPENDDS_ASSERT(!username_to_checklist_.count(a_username));
     username_to_checklist_[a_username] = a_checklist;
   }

◆ set_server_reflexive_address()

void OpenDDS::ICE::EndpointManager::set_server_reflexive_address	(	const ACE_INET_Addr &	a_server_reflexive_address,
		const ACE_INET_Addr &	a_stun_server_address
	)

private

Definition at line 227 of file EndpointManager.cpp.

References regenerate_agent_info(), server_reflexive_address_, and stun_server_address_.

Referenced by success_response().

 {
   if (server_reflexive_address_ != a_server_reflexive_address ||
       stun_server_address_ != a_stun_server_address) {
     server_reflexive_address_ = a_server_reflexive_address;
     stun_server_address_ = a_stun_server_address;
     regenerate_agent_info(false);
   }
 }

◆ start_ice()

void OpenDDS::ICE::EndpointManager::start_ice	(	const DCPS::GUID_t &	a_local_guid,
		const DCPS::GUID_t &	a_remote_guid,
		const AgentInfo &	a_remote_agent_info
	)

Definition at line 51 of file EndpointManager.cpp.

References agent_info_, change_username(), create_checklist(), guid_pair_to_checklist_, OpenDDS::ICE::AgentInfo::password, OpenDDS::ICE::AgentInfo::username, and username_to_checklist_.

 {
   // Check for username collision.
   if (a_remote_agent_info.username == agent_info_.username) {
     change_username();
   }
 
   GuidPair guidp(a_local_guid, a_remote_guid);
 
   // Try to find by guid.
   ChecklistPtr guid_checklist;
   {
     GuidPairToChecklistType::const_iterator pos = guid_pair_to_checklist_.find(guidp);
 
     if (pos != guid_pair_to_checklist_.end()) {
       guid_checklist = pos->second;
     }
   }
 
   // Try to find by username.
   ChecklistPtr username_checklist;
   {
     UsernameToChecklistType::const_iterator pos = username_to_checklist_.find(a_remote_agent_info.username);
 
     if (pos != username_to_checklist_.end()) {
       username_checklist = pos->second;
     }
 
     else {
       username_checklist = create_checklist(a_remote_agent_info);
     }
   }
 
   if (guid_checklist != username_checklist) {
     if (guid_checklist != 0) {
       guid_checklist->remove_guid(guidp);
     }
 
     username_checklist->add_guid(guidp);
   }
 
   AgentInfo old_remote_agent_info = username_checklist->original_remote_agent_info();
 
   if (old_remote_agent_info == a_remote_agent_info) {
     // No change.
     return;
   }
 
   old_remote_agent_info.password = a_remote_agent_info.password;
 
   if (old_remote_agent_info == a_remote_agent_info) {
     // Password change.
     username_checklist->set_remote_password(a_remote_agent_info.password);
     return;
   }
 
   // The remote agent changed its info without changing its username.
   GuidSetType const guids = username_checklist->guids();
   username_checklist->remove_guids();
   username_checklist = create_checklist(a_remote_agent_info);
   username_checklist->add_guids(guids);
 }

◆ stop_ice()

void OpenDDS::ICE::EndpointManager::stop_ice	(	const DCPS::GUID_t &	local_guid,
		const DCPS::GUID_t &	remote_guid
	)

Definition at line 116 of file EndpointManager.cpp.

References guid_pair_to_checklist_.

 {
   GuidPair guidp(a_local_guid, a_remote_guid);
 
   GuidPairToChecklistType::const_iterator pos = guid_pair_to_checklist_.find(guidp);
 
   if (pos != guid_pair_to_checklist_.end()) {
     ChecklistPtr guid_checklist = pos->second;
     guid_checklist->remove_guid(guidp);
   }
 }

◆ success_response() [1/2]

bool OpenDDS::ICE::EndpointManager::success_response ( const STUN::Message & a_message )

private

Definition at line 349 of file EndpointManager.cpp.

References ACE_ERROR, ACE_TEXT(), binding_request_, OpenDDS::STUN::Message::get_mapped_address(), LM_WARNING, next_stun_server_address_, requesting_, send_count_, set_server_reflexive_address(), OpenDDS::STUN::Message::transaction_id, and OpenDDS::STUN::Message::unknown_comprehension_required_attributes().

Referenced by receive(), and success_response().

 {
   if (a_message.transaction_id != binding_request_.transaction_id) {
     return false;
   }
 
   std::vector<STUN::AttributeType> unknown_attributes = a_message.unknown_comprehension_required_attributes();
 
   if (!unknown_attributes.empty()) {
     ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) EndpointManager::success_response: WARNING Unknown comprehension required attributes\n")));
     return true;
   }
 
   ACE_INET_Addr server_reflexive_address;
 
   if (a_message.get_mapped_address(server_reflexive_address)) {
     set_server_reflexive_address(server_reflexive_address, next_stun_server_address_);
     requesting_ = false;
     send_count_ = 0;
   }
 
   else {
     ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) EndpointManager::success_response: WARNING No (XOR)_MAPPED_ADDRESS attribute\n")));
     set_server_reflexive_address(ACE_INET_Addr(), ACE_INET_Addr());
     requesting_ = true;
     send_count_ = 0;
   }
 
   return true;
 }

◆ success_response() [2/2]

void OpenDDS::ICE::EndpointManager::success_response	(	const ACE_INET_Addr &	a_local_address,
		const ACE_INET_Addr &	a_remote_address,
		const STUN::Message &	a_message
	)

private

Definition at line 666 of file EndpointManager.cpp.

References ACE_ERROR, ACE_TEXT(), OpenDDS::STUN::BINDING, LM_WARNING, OpenDDS::STUN::Message::method, success_response(), OpenDDS::STUN::Message::transaction_id, and transaction_id_to_checklist_.

 {
   switch (a_message.method) {
   case STUN::BINDING: {
     if (success_response(a_message)) {
       return;
     }
 
     TransactionIdToChecklistType::const_iterator pos = transaction_id_to_checklist_.find(a_message.transaction_id);
 
     if (pos == transaction_id_to_checklist_.end()) {
       // Probably a check that got cancelled.
       return;
     }
 
     // Checklist is responsible for updating the map.
     // Checklist also checks for required parameters.
     pos->second->success_response(a_local_address, a_remote_address, a_message);
   }
   break;
 
   default:
     // Unknown method.  Stop processing.
     ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) EndpointManager::success_response: WARNING Unknown STUN method\n")));
     break;
   }
 }

◆ unfreeze() [1/2]

void OpenDDS::ICE::EndpointManager::unfreeze ( )

Definition at line 768 of file EndpointManager.cpp.

References username_to_checklist_.

 {
   for (UsernameToChecklistType::const_iterator pos = username_to_checklist_.begin(),
        limit = username_to_checklist_.end(); pos != limit; ++pos) {
     pos->second->unfreeze();
   }
 }

◆ unfreeze() [2/2]

void OpenDDS::ICE::EndpointManager::unfreeze ( const FoundationType & a_foundation )

Definition at line 776 of file EndpointManager.cpp.

References username_to_checklist_.

 {
   for (UsernameToChecklistType::const_iterator pos = username_to_checklist_.begin(),
        limit = username_to_checklist_.end(); pos != limit; ++pos) {
     pos->second->unfreeze(a_foundation);
   }
 }

◆ unset_responsible_checklist() [1/3]

void OpenDDS::ICE::EndpointManager::unset_responsible_checklist	(	const STUN::TransactionId &	a_transaction_id,
		ChecklistPtr	a_checklist
	)

inline

Definition at line 99 of file EndpointManager.h.

References OPENDDS_ASSERT.

Referenced by OpenDDS::ICE::Checklist::do_next_check(), OpenDDS::ICE::Checklist::error_response(), OpenDDS::ICE::Checklist::remove_guid(), OpenDDS::ICE::Checklist::succeeded(), and OpenDDS::ICE::Checklist::success_response().

   {
     TransactionIdToChecklistType::iterator pos = transaction_id_to_checklist_.find(a_transaction_id);
     OPENDDS_ASSERT(pos != transaction_id_to_checklist_.end());
     OPENDDS_ASSERT(pos->second == a_checklist);
     ACE_UNUSED_ARG(a_checklist);
     transaction_id_to_checklist_.erase(pos);
   }

◆ unset_responsible_checklist() [2/3]

void OpenDDS::ICE::EndpointManager::unset_responsible_checklist	(	const GuidPair &	a_guid_pair,
		ChecklistPtr	a_checklist
	)

inline

Definition at line 114 of file EndpointManager.h.

References OPENDDS_ASSERT.

   {
     GuidPairToChecklistType::iterator pos = guid_pair_to_checklist_.find(a_guid_pair);
     OPENDDS_ASSERT(pos != guid_pair_to_checklist_.end());
     OPENDDS_ASSERT(pos->second == a_checklist);
     ACE_UNUSED_ARG(a_checklist);
     guid_pair_to_checklist_.erase(pos);
   }

◆ unset_responsible_checklist() [3/3]

void OpenDDS::ICE::EndpointManager::unset_responsible_checklist	(	const std::string &	a_username,
		ChecklistPtr	a_checklist
	)

inline

Definition at line 129 of file EndpointManager.h.

References OPENDDS_ASSERT.

   {
     UsernameToChecklistType::iterator pos = username_to_checklist_.find(a_username);
     OPENDDS_ASSERT(pos != username_to_checklist_.end());
     OPENDDS_ASSERT(pos->second == a_checklist);
     ACE_UNUSED_ARG(a_checklist);
     username_to_checklist_.erase(pos);
   }

Member Data Documentation

◆ agent_impl

AgentImpl* const OpenDDS::ICE::EndpointManager::agent_impl

Definition at line 52 of file EndpointManager.h.

Referenced by OpenDDS::ICE::Checklist::add_triggered_check(), OpenDDS::ICE::Checklist::fix_foundations(), OpenDDS::ICE::Checklist::generate_triggered_check(), regenerate_agent_info(), OpenDDS::ICE::Checklist::remove_from_in_progress(), OpenDDS::ICE::Checklist::succeeded(), and OpenDDS::ICE::Checklist::unfreeze().

◆ agent_info_

AgentInfo OpenDDS::ICE::EndpointManager::agent_info_

private

Definition at line 173 of file EndpointManager.h.

Referenced by change_password(), change_username(), create_checklist(), EndpointManager(), indication(), make_bad_request_error_response(), make_unauthorized_error_response(), make_unknown_attributes_error_response(), regenerate_agent_info(), request(), and start_ice().

◆ agent_info_listeners_

AgentInfoListenersType OpenDDS::ICE::EndpointManager::agent_info_listeners_

private

Definition at line 199 of file EndpointManager.h.

Referenced by purge(), and regenerate_agent_info().

◆ binding_request_

STUN::Message OpenDDS::ICE::EndpointManager::binding_request_

private

Definition at line 180 of file EndpointManager.h.

Referenced by EndpointManager(), error_response(), server_reflexive_task(), and success_response().

◆ change_password_task_

DCPS::RcHandle<ChangePasswordTask> OpenDDS::ICE::EndpointManager::change_password_task_

private

Definition at line 257 of file EndpointManager.h.

◆ deferred_triggered_checks_

DeferredTriggeredChecksType OpenDDS::ICE::EndpointManager::deferred_triggered_checks_

private

Definition at line 184 of file EndpointManager.h.

Referenced by check_invariants(), create_checklist(), request(), and server_reflexive_task().

◆ endpoint

DCPS::WeakRcHandle<Endpoint> const OpenDDS::ICE::EndpointManager::endpoint

Definition at line 53 of file EndpointManager.h.

Referenced by EndpointManager(), network_change(), send(), and server_reflexive_task().

◆ foundations_

FoundationSet OpenDDS::ICE::EndpointManager::foundations_

private

Definition at line 174 of file EndpointManager.h.

Referenced by regenerate_agent_info().

◆ guid_pair_to_checklist_

GuidPairToChecklistType OpenDDS::ICE::EndpointManager::guid_pair_to_checklist_

private

Definition at line 196 of file EndpointManager.h.

Referenced by change_password(), check_invariants(), get_address(), start_ice(), and stop_ice().

◆ host_addresses_

AddressListType OpenDDS::ICE::EndpointManager::host_addresses_

private

Definition at line 169 of file EndpointManager.h.

Referenced by regenerate_agent_info(), and set_host_addresses().

◆ ice_tie_breaker_

ACE_UINT64 OpenDDS::ICE::EndpointManager::ice_tie_breaker_

private

Definition at line 172 of file EndpointManager.h.

Referenced by create_checklist(), and EndpointManager().

◆ next_stun_server_address_

ACE_INET_Addr OpenDDS::ICE::EndpointManager::next_stun_server_address_

private

Definition at line 179 of file EndpointManager.h.

Referenced by server_reflexive_task(), and success_response().

◆ requesting_

bool OpenDDS::ICE::EndpointManager::requesting_

private

Definition at line 177 of file EndpointManager.h.

Referenced by server_reflexive_task(), and success_response().

◆ send_count_

size_t OpenDDS::ICE::EndpointManager::send_count_

private

Definition at line 178 of file EndpointManager.h.

Referenced by server_reflexive_task(), and success_response().

◆ server_reflexive_address_

ACE_INET_Addr OpenDDS::ICE::EndpointManager::server_reflexive_address_

private

Definition at line 170 of file EndpointManager.h.

Referenced by regenerate_agent_info(), and set_server_reflexive_address().

◆ server_reflexive_task_

DCPS::RcHandle<ServerReflexiveTask> OpenDDS::ICE::EndpointManager::server_reflexive_task_

private

Definition at line 250 of file EndpointManager.h.

◆ stun_server_address_

ACE_INET_Addr OpenDDS::ICE::EndpointManager::stun_server_address_

private

Definition at line 171 of file EndpointManager.h.

Referenced by regenerate_agent_info(), and set_server_reflexive_address().

◆ transaction_id_to_checklist_

TransactionIdToChecklistType OpenDDS::ICE::EndpointManager::transaction_id_to_checklist_

private

Definition at line 192 of file EndpointManager.h.

Referenced by check_invariants(), error_response(), and success_response().

◆ username_to_checklist_

UsernameToChecklistType OpenDDS::ICE::EndpointManager::username_to_checklist_

private

Definition at line 188 of file EndpointManager.h.

Referenced by check_invariants(), compute_active_foundations(), indication(), purge(), regenerate_agent_info(), request(), start_ice(), and unfreeze().

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

Private Attributes
AddressListType	host_addresses_

ACE_INET_Addr	server_reflexive_address_

ACE_INET_Addr	stun_server_address_

ACE_UINT64	ice_tie_breaker_

AgentInfo	agent_info_

FoundationSet	foundations_

bool	requesting_

size_t	send_count_

ACE_INET_Addr	next_stun_server_address_

STUN::Message	binding_request_

DeferredTriggeredChecksType	deferred_triggered_checks_

UsernameToChecklistType	username_to_checklist_

TransactionIdToChecklistType	transaction_id_to_checklist_

GuidPairToChecklistType	guid_pair_to_checklist_

AgentInfoListenersType	agent_info_listeners_

DCPS::RcHandle< ServerReflexiveTask >	server_reflexive_task_

DCPS::RcHandle< ChangePasswordTask >	change_password_task_

Classes

Public Types

Public Member Functions

Public Attributes

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ AgentInfoListenersType

◆ DeferredTriggeredCheckListType

◆ DeferredTriggeredChecksType

◆ FoundationSet

◆ GuidPairToChecklistType

◆ TransactionIdToChecklistType

◆ UsernameToChecklistType

Constructor & Destructor Documentation

◆ EndpointManager()

Member Function Documentation

◆ add_agent_info_listener()

◆ agent_info()

◆ change_password()

◆ change_username()

◆ check_invariants()

◆ compute_active_foundations()

◆ create_checklist()

◆ error_response() [1/2]

◆ error_response() [2/2]

◆ foundations()

◆ get_address()

◆ ice_connect()

◆ ice_disconnect()

◆ indication()

◆ make_bad_request_error_response()

◆ make_unauthorized_error_response()

◆ make_unknown_attributes_error_response()

◆ network_change()

◆ purge()

◆ receive()

◆ regenerate_agent_info()

◆ remove_agent_info_listener()

◆ request()

◆ send()

◆ server_reflexive_task()

◆ set_host_addresses()

◆ set_responsible_checklist() [1/3]

◆ set_responsible_checklist() [2/3]

◆ set_responsible_checklist() [3/3]

◆ set_server_reflexive_address()

◆ start_ice()

◆ stop_ice()

◆ success_response() [1/2]

◆ success_response() [2/2]

◆ unfreeze() [1/2]

◆ unfreeze() [2/2]

◆ unset_responsible_checklist() [1/3]

◆ unset_responsible_checklist() [2/3]

◆ unset_responsible_checklist() [3/3]

Member Data Documentation

◆ agent_impl

◆ agent_info_

◆ agent_info_listeners_

◆ binding_request_

◆ change_password_task_

◆ deferred_triggered_checks_

◆ endpoint

◆ foundations_

◆ guid_pair_to_checklist_

◆ host_addresses_

◆ ice_tie_breaker_

◆ next_stun_server_address_

◆ requesting_

◆ send_count_

◆ server_reflexive_address_

◆ server_reflexive_task_

◆ stun_server_address_

◆ transaction_id_to_checklist_

◆ username_to_checklist_