#include <UdpTransport.h>

Inheritance diagram for OpenDDS::DCPS::UdpTransport:

Collaboration diagram for OpenDDS::DCPS::UdpTransport:

[legend]

Public Member Functions
	UdpTransport (const UdpInst_rch &inst)

void	passive_connection (const ACE_INET_Addr &remote_address, const ReceivedDataSample &data)

UdpInst_rch	config () const

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

virtual void	unbind_link (DataLink *link)
	Remove any pending_release mappings. More...

bool	release_link_resources (DataLink *link)

TransportInst_rch	config () const

virtual void	register_for_reader (const GUID_t &, const GUID_t &, const GUID_t &, const TransportLocatorSeq &, OpenDDS::DCPS::DiscoveryListener *)

virtual void	unregister_for_reader (const GUID_t &, const GUID_t &, const GUID_t &)

virtual void	register_for_writer (const GUID_t &, const GUID_t &, const GUID_t &, const TransportLocatorSeq &, DiscoveryListener *)

virtual void	unregister_for_writer (const GUID_t &, const GUID_t &, const GUID_t &)

virtual void	update_locators (const GUID_t &, const TransportLocatorSeq &)

virtual void	get_last_recv_locator (const GUID_t &, TransportLocator &)

virtual void	rtps_relay_address_change ()

virtual void	append_transport_statistics (TransportStatisticsSequence &)

ACE_Reactor_Timer_Interface *	timer () const
	Interface to the transport's reactor for scheduling timers. More...

ACE_Reactor *	reactor () const

ACE_thread_t	reactor_owner () const

bool	is_shut_down () const

void	create_reactor_task (bool useAsyncSend=false, const OPENDDS_STRING &name="")

void	dump ()
	Diagnostic aid. More...

OPENDDS_STRING	dump_to_str ()

void	report ()

virtual WeakRcHandle< ICE::Endpoint >	get_ice_endpoint ()

virtual void	rtps_relay_only_now (bool)

virtual void	use_rtps_relay_now (bool)

virtual void	use_ice_now (bool)

ReactorTask_rch	reactor_task ()

EventDispatcher_rch	event_dispatcher ()

int	acquire ()

int	tryacquire ()

int	release ()

int	remove ()

bool	connection_info (TransportLocator &local_info, ConnectionInfoFlags flags) const

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

Protected Member Functions
virtual AcceptConnectResult	connect_datalink (const RemoteTransport &remote, const ConnectionAttribs &attribs, const TransportClient_rch &client)

virtual AcceptConnectResult	accept_datalink (const RemoteTransport &remote, const ConnectionAttribs &attribs, const TransportClient_rch &client)

virtual void	stop_accepting_or_connecting (const TransportClient_wrch &client, const GUID_t &remote_id, bool disassociate, bool association_failed)

bool	configure_i (const UdpInst_rch &config)

virtual void	shutdown_i ()

virtual bool	connection_info_i (TransportLocator &info, ConnectionInfoFlags flags) const

ACE_INET_Addr	get_connection_addr (const TransportBLOB &data) const

virtual void	release_datalink (DataLink *link)

virtual std::string	transport_type () const

Protected Member Functions inherited from OpenDDS::DCPS::TransportImpl
	TransportImpl (TransportInst_rch config)

bool	open ()

typedef	OPENDDS_MULTIMAP (TransportClient_wrch, DataLink_rch) PendConnMap

void	add_pending_connection (const TransportClient_rch &client, DataLink_rch link)

void	shutdown ()

Protected Member Functions inherited from OpenDDS::DCPS::RcObject
	RcObject ()

Private Types
typedef ACE_SYNCH_MUTEX	LockType

typedef ACE_Guard< LockType >	GuardType

typedef ConditionVariable< LockType >	ConditionVariableType

typedef std::vector< DataLink::OnStartCallback >	Callbacks

Private Member Functions
UdpDataLink_rch	make_datalink (const ACE_INET_Addr &remote_address, Priority priority, bool active)

PriorityKey	blob_to_key (const TransportBLOB &remote, Priority priority, ACE_INET_Addr local_addr, bool active)

typedef	OPENDDS_MAP (PriorityKey, UdpDataLink_rch) UdpDataLinkMap
	Map of fully associated DataLinks for this transport. Protected. More...

typedef	OPENDDS_MAP (PriorityKey, Callbacks) PendConnMap

Private Attributes
LockType	client_links_lock_
	This lock is used to protect the client_links_ data member. More...

UdpDataLinkMap	client_links_

UdpDataLink_rch	server_link_
	The single datalink for the passive side. No locking required. More...

ACE_Recursive_Thread_Mutex	connections_lock_

std::set< PriorityKey >	server_link_keys_

PendConnMap	pending_connections_

std::set< PriorityKey >	pending_server_link_keys_

Additional Inherited Members
Public Attributes inherited from OpenDDS::DCPS::TransportImpl
LockType	lock_
	Lock to protect the config_ and reactor_task_ data members. More...

WeakRcHandle< TransportInst >	config_

ReactorTask_rch	reactor_task_

EventDispatcher_rch	event_dispatcher_
	smart ptr to the associated DL cleanup task More...

unique_ptr< Monitor >	monitor_
	Monitor object for this entity. More...

Protected Types inherited from OpenDDS::DCPS::TransportImpl
typedef ACE_SYNCH_MUTEX	LockType

typedef ACE_Guard< LockType >	GuardType

Protected Attributes inherited from OpenDDS::DCPS::TransportImpl
LockType	pending_connections_lock_
	Lock to protect the pending_connections_ data member. More...

PendConnMap	pending_connections_

AtomicBool	is_shut_down_
	Id of the last link established. More...

Detailed Description

Definition at line 29 of file UdpTransport.h.

Member Typedef Documentation

◆ Callbacks

typedef std::vector<DataLink::OnStartCallback> OpenDDS::DCPS::UdpTransport::Callbacks

private

Definition at line 94 of file UdpTransport.h.

◆ ConditionVariableType

typedef ConditionVariable<LockType> OpenDDS::DCPS::UdpTransport::ConditionVariableType

private

Definition at line 70 of file UdpTransport.h.

◆ GuardType

typedef ACE_Guard<LockType> OpenDDS::DCPS::UdpTransport::GuardType

private

Definition at line 69 of file UdpTransport.h.

◆ LockType

typedef ACE_SYNCH_MUTEX OpenDDS::DCPS::UdpTransport::LockType

private

Definition at line 68 of file UdpTransport.h.

Constructor & Destructor Documentation

◆ UdpTransport()

OpenDDS::DCPS::UdpTransport::UdpTransport ( const UdpInst_rch & inst )

explicit

Definition at line 35 of file UdpTransport.cpp.

References configure_i(), and OpenDDS::DCPS::TransportImpl::open().

   : TransportImpl(inst)
 {
   if (!(configure_i(inst) && open())) {
     throw Transport::UnableToCreate();
   }
 }

Member Function Documentation

◆ accept_datalink()

TransportImpl::AcceptConnectResult OpenDDS::DCPS::UdpTransport::accept_datalink	(	const RemoteTransport &	remote,
		const ConnectionAttribs &	attribs,
		const TransportClient_rch &	client
	)

protectedvirtual

accept_datalink() is called from TransportClient to initiate an association as the passive peer. A DataLink may be returned if one is already connected and ready to use, otherwise passively wait for a physical connection from the active side (either in the form of a connection event or handshaking message). Upon completion of the physical connection, the transport calls back to TransportClient::use_datalink().

Implements OpenDDS::DCPS::TransportImpl.

Definition at line 113 of file UdpTransport.cpp.

References OpenDDS::DCPS::TransportImpl::AcceptConnectResult::ACR_FAILED, OpenDDS::DCPS::TransportImpl::AcceptConnectResult::ACR_SUCCESS, OpenDDS::DCPS::PriorityKey::address(), OpenDDS::DCPS::TransportImpl::RemoteTransport::blob_, blob_to_key(), config(), connections_lock_, OpenDDS::DCPS::PriorityKey::is_active(), OpenDDS::DCPS::PriorityKey::is_loopback(), OpenDDS::DCPS::TransportImpl::is_shut_down(), LM_DEBUG, pending_connections_, pending_server_link_keys_, OpenDDS::DCPS::PriorityKey::priority(), OpenDDS::DCPS::TransportImpl::ConnectionAttribs::priority_, OpenDDS::DCPS::TransportImpl::RemoteTransport::repo_id_, server_link_, server_link_keys_, VDBG, and VDBG_LVL.

 {
   UdpInst_rch cfg = config();
   if (!cfg && is_shut_down()) {
     return AcceptConnectResult(AcceptConnectResult::ACR_FAILED);
   }
   ACE_Guard<ACE_Recursive_Thread_Mutex> guard(connections_lock_);
 
   const PriorityKey key = blob_to_key(remote.blob_,
                                       attribs.priority_, cfg->local_address(), false /* !active */);
 
   VDBG_LVL((LM_DEBUG, "(%P|%t) UdpTransport::accept_datalink PriorityKey "
             "prio=%d, addr=%C, is_loopback=%d, is_active=%d\n",
             key.priority(), LogAddr(key.address()).c_str(), key.is_loopback(),
             key.is_active()), 2);
 
   if (server_link_keys_.count(key)) {
     VDBG((LM_DEBUG, "(%P|%t) UdpTransport::accept_datalink found\n"));
     return AcceptConnectResult(UdpDataLink_rch(server_link_));
   } else if (pending_server_link_keys_.count(key)) {
     pending_server_link_keys_.erase(key);
     server_link_keys_.insert(key);
     VDBG((LM_DEBUG, "(%P|%t) UdpTransport::accept_datalink completed\n"));
     return AcceptConnectResult(UdpDataLink_rch(server_link_));
   } else {
     const DataLink::OnStartCallback callback(client, remote.repo_id_);
     pending_connections_[key].push_back(callback);
     VDBG((LM_DEBUG, "(%P|%t) UdpTransport::accept_datalink pending\n"));
     return AcceptConnectResult(AcceptConnectResult::ACR_SUCCESS);
   }
   return AcceptConnectResult();
 }

◆ blob_to_key()

PriorityKey OpenDDS::DCPS::UdpTransport::blob_to_key	(	const TransportBLOB &	remote,
		Priority	priority,
		ACE_INET_Addr	local_addr,
		bool	active
	)

private

Definition at line 256 of file UdpTransport.cpp.

References ACE_ERROR, ACE_TEXT(), LM_ERROR, and OpenDDS::DCPS::NetworkResource::to_addr().

Referenced by accept_datalink(), connect_datalink(), and passive_connection().

 {
   NetworkResource network_resource;
   ACE_InputCDR cdr((const char*)remote.get_buffer(), remote.length());
 
   if (!(cdr >> network_resource)) {
     ACE_ERROR((LM_ERROR,
                ACE_TEXT("(%P|%t) ERROR: UdpTransport::blob_to_key")
                ACE_TEXT(" failed to de-serialize the NetworkResource\n")));
   }
 
   ACE_INET_Addr remote_address;
   network_resource.to_addr(remote_address);
   const bool is_loopback = remote_address == local_addr;
 
   return PriorityKey(priority, remote_address, is_loopback, active);
 }

◆ config()

UdpInst_rch OpenDDS::DCPS::UdpTransport::config ( ) const

Definition at line 44 of file UdpTransport.cpp.

References OpenDDS::DCPS::TransportImpl::config(), and OpenDDS::DCPS::dynamic_rchandle_cast().

Referenced by accept_datalink(), connect_datalink(), connection_info_i(), and passive_connection().

 {
   return dynamic_rchandle_cast<UdpInst>(TransportImpl::config());
 }

◆ configure_i()

bool OpenDDS::DCPS::UdpTransport::configure_i ( const UdpInst_rch & config )

protected

Definition at line 174 of file UdpTransport.cpp.

References OpenDDS::DCPS::TransportImpl::create_reactor_task(), make_datalink(), server_link_, and TheServiceParticipant.

Referenced by UdpTransport().

 {
   if (!config) {
     return false;
   }
   create_reactor_task(false, "UdpTransport" + config->name());
 
   // Override with DCPSDefaultAddress.
   if (config->local_address() == ACE_INET_Addr() &&
       TheServiceParticipant->default_address().to_addr() != ACE_INET_Addr()) {
     config->local_address(TheServiceParticipant->default_address().to_addr());
   }
 
   // Our "server side" data link is created here, similar to the acceptor_
   // in the TcpTransport implementation.  This establishes a socket as an
   // endpoint that we can advertise to peers via connection_info_i().
   server_link_ = make_datalink(config->local_address(), 0 /* priority */, false);
   return true;
 }

◆ connect_datalink()

TransportImpl::AcceptConnectResult OpenDDS::DCPS::UdpTransport::connect_datalink	(	const RemoteTransport &	remote,
		const ConnectionAttribs &	attribs,
		const TransportClient_rch &	client
	)

protectedvirtual

connect_datalink() is called from TransportClient to initiate an association as the active peer. A DataLink may be returned if one is already connected and ready to use, otherwise initiate a connection to the passive side and return from this method. Upon completion of the physical connection, the transport calls back to TransportClient::use_datalink().

Implements OpenDDS::DCPS::TransportImpl.

Definition at line 71 of file UdpTransport.cpp.

References OpenDDS::DCPS::TransportImpl::AcceptConnectResult::ACR_FAILED, OpenDDS::DCPS::PriorityKey::address(), OpenDDS::DCPS::TransportImpl::RemoteTransport::blob_, blob_to_key(), client_links_, client_links_lock_, config(), get_connection_addr(), OpenDDS::DCPS::PriorityKey::is_active(), OpenDDS::DCPS::PriorityKey::is_loopback(), OpenDDS::DCPS::RcHandle< T >::is_nil(), OpenDDS::DCPS::TransportImpl::is_shut_down(), LM_DEBUG, make_datalink(), OpenDDS::DCPS::PriorityKey::priority(), OpenDDS::DCPS::TransportImpl::ConnectionAttribs::priority_, VDBG, and VDBG_LVL.

 {
   UdpInst_rch cfg = config();
   if (!cfg && is_shut_down()) {
     return AcceptConnectResult(AcceptConnectResult::ACR_FAILED);
   }
   const ACE_INET_Addr remote_address = get_connection_addr(remote.blob_);
   const bool active = true;
   const PriorityKey key = blob_to_key(remote.blob_, attribs.priority_, cfg->local_address(), active);
 
   VDBG_LVL((LM_DEBUG, "(%P|%t) UdpTransport::connect_datalink PriorityKey "
             "prio=%d, addr=%C, is_loopback=%d, is_active=%d\n",
             key.priority(), LogAddr(key.address()).c_str(), key.is_loopback(),
             key.is_active()), 2);
 
   GuardType guard(client_links_lock_);
   if (this->is_shut_down()) {
     return AcceptConnectResult(AcceptConnectResult::ACR_FAILED);
   }
 
   const UdpDataLinkMap::iterator it(client_links_.find(key));
   if (it != client_links_.end()) {
     VDBG((LM_DEBUG, "(%P|%t) UdpTransport::connect_datalink found\n"));
     return AcceptConnectResult(UdpDataLink_rch(it->second));
   }
 
   // Create new DataLink for logical connection:
   UdpDataLink_rch link (make_datalink(remote_address,
                                        attribs.priority_,
                                        active));
 
   if (!link.is_nil()) {
     client_links_.insert(UdpDataLinkMap::value_type(key, link));
     VDBG((LM_DEBUG, "(%P|%t) UdpTransport::connect_datalink connected\n"));
   }
 
   return AcceptConnectResult(link);
 }

◆ connection_info_i()

bool OpenDDS::DCPS::UdpTransport::connection_info_i	(	TransportLocator &	local_info,
		ConnectionInfoFlags	flags
	)		const

protectedvirtual

Called by our connection_info() method to allow the concrete TransportImpl subclass to do the dirty work since it really is the one that knows how to populate the supplied TransportLocator object.

Implements OpenDDS::DCPS::TransportImpl.

Definition at line 212 of file UdpTransport.cpp.

References config().

 {
   UdpInst_rch cfg = config();
   if (cfg) {
     cfg->populate_locator(info, flags);
     return true;
   }
   return false;
 }

◆ get_connection_addr()

ACE_INET_Addr OpenDDS::DCPS::UdpTransport::get_connection_addr ( const TransportBLOB & data ) const

protected

Definition at line 223 of file UdpTransport.cpp.

References OpenDDS::DCPS::NetworkResource::to_addr().

Referenced by connect_datalink().

 {
   ACE_INET_Addr local_address;
   NetworkResource network_resource;
 
   size_t len = data.length();
   const char* buffer = reinterpret_cast<const char*>(data.get_buffer());
 
   ACE_InputCDR cdr(buffer, len);
   if (cdr >> network_resource) {
     network_resource.to_addr(local_address);
   }
 
   return local_address;
 }

◆ make_datalink()

UdpDataLink_rch OpenDDS::DCPS::UdpTransport::make_datalink	(	const ACE_INET_Addr &	remote_address,
		Priority	priority,
		bool	active
	)

private

Definition at line 51 of file UdpTransport.cpp.

References ACE_ERROR, ACE_TEXT(), LM_ERROR, OpenDDS::DCPS::UdpDataLink::open(), OpenDDS::DCPS::rchandle_from(), and OpenDDS::DCPS::TransportImpl::reactor_task().

Referenced by configure_i(), and connect_datalink().

 {
   UdpDataLink_rch link(make_rch<UdpDataLink>(rchandle_from(this), priority, reactor_task(), active));
   // Configure link with transport configuration and reactor task:
 
   // Open logical connection:
   if (link->open(remote_address)) {
     return link;
   }
 
   ACE_ERROR((LM_ERROR,
               ACE_TEXT("(%P|%t) ERROR: ")
               ACE_TEXT("UdpTransport::make_datalink: ")
               ACE_TEXT("failed to open DataLink!\n")));
 
   return UdpDataLink_rch();
 }

◆ OPENDDS_MAP() [1/2]

typedef OpenDDS::DCPS::UdpTransport::OPENDDS_MAP	(	PriorityKey	,
		UdpDataLink_rch
	)

private

Map of fully associated DataLinks for this transport. Protected.

◆ OPENDDS_MAP() [2/2]

typedef OpenDDS::DCPS::UdpTransport::OPENDDS_MAP	(	PriorityKey	,
		Callbacks
	)

private

◆ passive_connection()

void OpenDDS::DCPS::UdpTransport::passive_connection	(	const ACE_INET_Addr &	remote_address,
		const ReceivedDataSample &	data
	)

Definition at line 278 of file UdpTransport.cpp.

References blob_to_key(), config(), connections_lock_, OpenDDS::DCPS::ReceivedDataSample::data(), OpenDDS::DCPS::ReceivedDataSample::data_length(), OpenDDS::DCPS::find(), LM_DEBUG, OpenDDS::DCPS::WeakRcHandle< T >::lock(), OPENDDS_END_VERSIONED_NAMESPACE_DECL, pending_connections_, pending_server_link_keys_, ACE_SOCK_Dgram::send(), server_link_, server_link_keys_, OpenDDS::DCPS::UdpDataLink::socket(), OpenDDS::DCPS::static_rchandle_cast(), and VDBG.

 {
   UdpInst_rch cfg = config();
   if (!cfg) {
     return;
   }
   const size_t blob_len = data.data_length() - sizeof(Priority);
   Message_Block_Ptr payload(data.data());
   Priority priority;
   Serializer serializer(payload.get(), encoding_kind);
   serializer >> priority;
   TransportBLOB blob(static_cast<CORBA::ULong>(blob_len));
   blob.length(blob.maximum());
   serializer.read_octet_array(blob.get_buffer(), blob.length());
 
   // Send an ack so that the active side can return from
   // connect_datalink_i().  This is just a single byte of
   // arbitrary data, the remote side is not yet using the
   // framework (TransportHeader, DataSampleHeader,
   // ReceiveStrategy).
   const char ack_data = 23;
   if (server_link_->socket().send(&ack_data, 1, remote_address) <= 0) {
     VDBG((LM_DEBUG, "(%P|%t) UdpTransport::passive_connection failed to send ack\n"));
   }
 
   const PriorityKey key = blob_to_key(blob, priority, cfg->local_address(), false /* passive */);
 
   ACE_Guard<ACE_Recursive_Thread_Mutex> guard(connections_lock_);
 
   const PendConnMap::iterator pend = pending_connections_.find(key);
 
   if (pend != pending_connections_.end()) {
 
      //don't hold connections_lock_ while calling use_datalink
      //guard.release();
 
     VDBG((LM_DEBUG, "(%P|%t) UdpTransport::passive_connection completing\n"));
 
     const DataLink_rch link = static_rchandle_cast<DataLink>(server_link_);
 
     //Insert key now to make sure when releasing guard to call use_datalink
     //if an accept_datalink obtains lock first it will see that it can proceed
     //with using the link and do its own use_datalink call.
     server_link_keys_.insert(key);
 
     //create a copy of the size of callback vector so that if use_datalink_i -> stop_accepting_or_connecting
     //finds that callbacks vector is empty and deletes pending connection & its callback vector for loop can
     //still exit the loop without checking the size of invalid memory
     //size_t num_callbacks = pend->second.size();
 
     //Create a copy of the vector of callbacks to process, making sure that each is
     //still present in the actual pending_connections_ before calling use_datalink
     Callbacks tmp(pend->second);
     for (size_t i = 0; i < tmp.size(); ++i) {
       const PendConnMap::iterator pend = pending_connections_.find(key);
       if (pend != pending_connections_.end()) {
         const Callbacks::iterator tmp_iter = find(pend->second.begin(),
                                                   pend->second.end(),
                                                   tmp.at(i));
         if (tmp_iter != pend->second.end()) {
           TransportClient_wrch pend_client = tmp.at(i).first;
           GUID_t remote_repo = tmp.at(i).second;
           guard.release();
           TransportClient_rch client = pend_client.lock();
           if (client)
             client->use_datalink(remote_repo, link);
           guard.acquire();
         }
       }
     }
   } else {
     // still hold guard(connections_lock_) at this point so
     // pending_server_link_keys_ is protected for insert
 
     VDBG((LM_DEBUG, "(%P|%t) UdpTransport::passive_connection pending\n"));
     // accept_datalink() will complete the connection.
     pending_server_link_keys_.insert(key);
   }
 }

◆ release_datalink()

void OpenDDS::DCPS::UdpTransport::release_datalink ( DataLink * link )

protectedvirtual

Called by the TransportRegistry when this TransportImpl object is released while the TransportRegistry is handling a release() "event". The DataLink itself calls this method when it thinks it is no longer used for any associations. This occurs during a "remove associations" operation being performed by some TransportClient that uses this TransportImpl. The TransportClient is known to have acquired our reservation_lock_, so there won't be any reserve_datalink() calls being made from any other threads while we perform this release.

Implements OpenDDS::DCPS::TransportImpl.

Definition at line 240 of file UdpTransport.cpp.

References client_links_, client_links_lock_, and OpenDDS::DCPS::DataLink::stop().

 {
   GuardType guard(client_links_lock_);
   for (UdpDataLinkMap::iterator it(client_links_.begin());
        it != client_links_.end(); ++it) {
     // We are guaranteed to have exactly one matching DataLink
     // in the map; release any resources held and return.
     if (link == static_cast<DataLink*>(it->second.in())) {
       link->stop();
       client_links_.erase(it);
       return;
     }
   }
 }

◆ shutdown_i()

void OpenDDS::DCPS::UdpTransport::shutdown_i ( )

protectedvirtual

Called during the shutdown() method in order to give the concrete TransportImpl subclass a chance to do something when the shutdown "event" occurs.

Implements OpenDDS::DCPS::TransportImpl.

Definition at line 195 of file UdpTransport.cpp.

References client_links_, client_links_lock_, OpenDDS::DCPS::RcHandle< T >::reset(), server_link_, and OpenDDS::DCPS::DataLink::transport_shutdown().

 {
   // Shutdown reserved datalinks and release configuration:
   GuardType guard(client_links_lock_);
   for (UdpDataLinkMap::iterator it(client_links_.begin());
        it != client_links_.end(); ++it) {
     it->second->transport_shutdown();
   }
   client_links_.clear();
 
   if (server_link_) {
     server_link_->transport_shutdown();
     server_link_.reset();
   }
 }

◆ stop_accepting_or_connecting()

void OpenDDS::DCPS::UdpTransport::stop_accepting_or_connecting	(	const TransportClient_wrch &	client,
		const GUID_t &	remote_id,
		bool	disassociate,
		bool	association_failed
	)

protectedvirtual

stop_accepting_or_connecting() is called from TransportClient to terminate the accepting process begun by accept_datalink() or connect_datalink(). This allows the TransportImpl to clean up any resources associated with this pending connection. The TransportClient* passed in to accept or connect is not valid after this method is called.

Implements OpenDDS::DCPS::TransportImpl.

Definition at line 149 of file UdpTransport.cpp.

References connections_lock_, LM_DEBUG, pending_connections_, and VDBG.

 {
   VDBG((LM_DEBUG, "(%P|%t) UdpTransport::stop_accepting_or_connecting\n"));
 
   ACE_Guard<ACE_Recursive_Thread_Mutex> guard(connections_lock_);
 
   for (PendConnMap::iterator it = pending_connections_.begin();
        it != pending_connections_.end(); ++it) {
     for (size_t i = 0; i < it->second.size(); ++i) {
       if (it->second[i].first == client && it->second[i].second == remote_id) {
         it->second.erase(it->second.begin() + i);
         break;
       }
     }
     if (it->second.empty()) {
       pending_connections_.erase(it);
       return;
     }
   }
 }

◆ transport_type()

virtual std::string OpenDDS::DCPS::UdpTransport::transport_type ( ) const

inlineprotectedvirtual

Implements OpenDDS::DCPS::TransportImpl.

Definition at line 59 of file UdpTransport.h.

59 { return "udp"; }

Member Data Documentation

◆ client_links_

UdpDataLinkMap OpenDDS::DCPS::UdpTransport::client_links_

private

Definition at line 78 of file UdpTransport.h.

Referenced by connect_datalink(), release_datalink(), and shutdown_i().

◆ client_links_lock_

LockType OpenDDS::DCPS::UdpTransport::client_links_lock_

private

This lock is used to protect the client_links_ data member.

Definition at line 73 of file UdpTransport.h.

Referenced by connect_datalink(), release_datalink(), and shutdown_i().

◆ connections_lock_

ACE_Recursive_Thread_Mutex OpenDDS::DCPS::UdpTransport::connections_lock_

private

This protects the pending_connections_, pending_server_link_keys_, and server_link_keys_ data members.

Definition at line 86 of file UdpTransport.h.

Referenced by accept_datalink(), passive_connection(), and stop_accepting_or_connecting().

◆ pending_connections_

PendConnMap OpenDDS::DCPS::UdpTransport::pending_connections_

private

Locked by connections_lock_. Tracks expected connections that we have learned about in accept_datalink() but have not yet performed the handshake.

Definition at line 99 of file UdpTransport.h.

Referenced by accept_datalink(), passive_connection(), and stop_accepting_or_connecting().

◆ pending_server_link_keys_

std::set<PriorityKey> OpenDDS::DCPS::UdpTransport::pending_server_link_keys_

private

Locked by connections_lock_. These are passive-side PriorityKeys that have finished handshaking, but have not been processed by accept_datalink()

Definition at line 104 of file UdpTransport.h.

Referenced by accept_datalink(), and passive_connection().

◆ server_link_

UdpDataLink_rch OpenDDS::DCPS::UdpTransport::server_link_

private

The single datalink for the passive side. No locking required.

Definition at line 81 of file UdpTransport.h.

Referenced by accept_datalink(), configure_i(), passive_connection(), and shutdown_i().

◆ server_link_keys_

std::set<PriorityKey> OpenDDS::DCPS::UdpTransport::server_link_keys_

private

Locked by connections_lock_. These are passive-side PriorityKeys that have been fully associated (processed by accept_datalink() and finished handshaking). They are ready for use and reuse via server_link_.

Definition at line 92 of file UdpTransport.h.

Referenced by accept_datalink(), and passive_connection().

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

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Callbacks

◆ ConditionVariableType

◆ GuardType

◆ LockType

Constructor & Destructor Documentation

◆ UdpTransport()

Member Function Documentation

◆ accept_datalink()

◆ blob_to_key()

◆ config()

◆ configure_i()

◆ connect_datalink()

◆ connection_info_i()

◆ get_connection_addr()

◆ make_datalink()

◆ OPENDDS_MAP() [1/2]

◆ OPENDDS_MAP() [2/2]

◆ passive_connection()

◆ release_datalink()

◆ shutdown_i()

◆ stop_accepting_or_connecting()

◆ transport_type()

Member Data Documentation

◆ client_links_

◆ client_links_lock_

◆ connections_lock_

◆ pending_connections_

◆ pending_server_link_keys_

◆ server_link_

◆ server_link_keys_