OpenDDS::DCPS::UdpTransport Class Reference

#include <UdpTransport.h>

Inheritance diagram for OpenDDS::DCPS::UdpTransport:

[legend]

Collaboration diagram for OpenDDS::DCPS::UdpTransport:

[legend]

List of all members.

Public Member Functions
	UdpTransport (UdpInst &inst)
void	passive_connection (const ACE_INET_Addr &remote_address, const Message_Block_Ptr &data)
UdpInst &	config () 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 RepoId &remote_id)
bool	configure_i (UdpInst &config)
virtual void	shutdown_i ()
virtual bool	connection_info_i (TransportLocator &info) const
ACE_INET_Addr	get_connection_addr (const TransportBLOB &data) const
virtual void	release_datalink (DataLink *link)
virtual std::string	transport_type () const
Private Types
typedef ACE_SYNCH_MUTEX	LockType
typedef ACE_Guard< LockType >	GuardType
typedef ACE_Condition< LockType >	ConditionType
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.
typedef	OPENDDS_MAP (PriorityKey, Callbacks) PendConnMap
Private Attributes
LockType	client_links_lock_
	This lock is used to protect the client_links_ data member.
UdpDataLinkMap	client_links_
UdpDataLink_rch	server_link_
	The single datalink for the passive side. No locking required.
ACE_Recursive_Thread_Mutex	connections_lock_
std::set< PriorityKey >	server_link_keys_
PendConnMap	pending_connections_
std::set< PriorityKey >	pending_server_link_keys_

---

Detailed Description

Definition at line 28 of file UdpTransport.h.

---

Member Typedef Documentation

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

Definition at line 91 of file UdpTransport.h.

typedef ACE_Condition<LockType> OpenDDS::DCPS::UdpTransport::ConditionType [private]

Definition at line 67 of file UdpTransport.h.

typedef ACE_Guard<LockType> OpenDDS::DCPS::UdpTransport::GuardType [private]

Reimplemented from OpenDDS::DCPS::TransportImpl.

Definition at line 66 of file UdpTransport.h.

typedef ACE_SYNCH_MUTEX OpenDDS::DCPS::UdpTransport::LockType [private]

Reimplemented from OpenDDS::DCPS::TransportImpl.

Definition at line 65 of file UdpTransport.h.

---

Constructor & Destructor Documentation

OpenDDS::DCPS::UdpTransport::UdpTransport

(

UdpInst &

inst

)

[explicit]

Definition at line 28 of file UdpTransport.cpp.

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

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

Here is the call graph for this function:

---

Member Function Documentation

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

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 102 of file UdpTransport.cpp.

References OpenDDS::DCPS::TransportImpl::AcceptConnectResult::ACR_SUCCESS, OpenDDS::DCPS::TransportImpl::RemoteTransport::blob_, blob_to_key(), config(), connections_lock_, LM_DEBUG, pending_connections_, pending_server_link_keys_, OpenDDS::DCPS::TransportImpl::ConnectionAttribs::priority_, OpenDDS::DCPS::TransportImpl::RemoteTransport::repo_id_, server_link_, server_link_keys_, and VDBG.

{
  ACE_Guard<ACE_Recursive_Thread_Mutex> guard(connections_lock_);
  //GuardType guard(connections_lock_);
  const PriorityKey key = blob_to_key(remote.blob_,
                                      attribs.priority_, config().local_address(), false /* !active */);
  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();
}

Here is the call graph for this function:

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

Definition at line 230 of file UdpTransport.cpp.

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

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

{
  NetworkAddress network_order_address;
  ACE_InputCDR cdr((const char*)remote.get_buffer(), remote.length());

  if (!(cdr >> network_order_address)) {
    ACE_ERROR((LM_ERROR,
               ACE_TEXT("(%P|%t) ERROR: UdpTransport::blob_to_key")
               ACE_TEXT(" failed to de-serialize the NetworkAddress\n")));
  }

  ACE_INET_Addr remote_address;
  network_order_address.to_addr(remote_address);
  const bool is_loopback = remote_address == local_addr;

  return PriorityKey(priority, remote_address, is_loopback, active);
}

Here is the call graph for this function:

Here is the caller graph for this function:

UdpInst & OpenDDS::DCPS::UdpTransport::config

(

)

const

Expose the configuration information so others can see what we can do.

Reimplemented from OpenDDS::DCPS::TransportImpl.

Definition at line 37 of file UdpTransport.cpp.

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

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

Here is the caller graph for this function:

bool OpenDDS::DCPS::UdpTransport::configure_i

(

UdpInst &

config

)

[protected]

Definition at line 154 of file UdpTransport.cpp.

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

Referenced by UdpTransport().

{
  create_reactor_task();

  // Override with DCPSDefaultAddress.
  if (config.local_address() == ACE_INET_Addr () &&
      !TheServiceParticipant->default_address ().empty ()) {

    config.local_address(0, TheServiceParticipant->default_address ().c_str ());
  }

  // 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

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 65 of file UdpTransport.cpp.

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

{

  if (this->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_, this->config().local_address(), active);

  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);
}

Here is the call graph for this function:

bool OpenDDS::DCPS::UdpTransport::connection_info_i

(

TransportLocator &

local_info

)

const [protected, virtual]

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 190 of file UdpTransport.cpp.

References config(), and OpenDDS::DCPS::UdpInst::populate_locator().

{
  this->config().populate_locator(info);
  return true;
}

Here is the call graph for this function:

ACE_INET_Addr OpenDDS::DCPS::UdpTransport::get_connection_addr

(

const TransportBLOB &

data

)

const [protected]

Definition at line 197 of file UdpTransport.cpp.

References len, and OpenDDS::DCPS::NetworkAddress::to_addr().

Referenced by connect_datalink().

{
  ACE_INET_Addr local_address;
  NetworkAddress network_address;

  size_t len = data.length();
  const char* buffer = reinterpret_cast<const char*>(data.get_buffer());

  ACE_InputCDR cdr(buffer, len);
  if (cdr >> network_address) {
    network_address.to_addr(local_address);
  }

  return local_address;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 44 of file UdpTransport.cpp.

References ACE_TEXT(), OpenDDS::DCPS::RcHandle< T >::in(), LM_ERROR, OpenDDS::DCPS::TransportImpl::reactor_task(), and OpenDDS::DCPS::ref().

Referenced by configure_i(), and connect_datalink().

{
  TransportReactorTask_rch rtask (reactor_task());
  UdpDataLink_rch link(make_rch<UdpDataLink>(ref(*this), priority, rtask.in(), 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();
}

Here is the call graph for this function:

Here is the caller graph for this function:

typedef OpenDDS::DCPS::UdpTransport::OPENDDS_MAP	(	PriorityKey	,
		Callbacks
	)			[private]

typedef OpenDDS::DCPS::UdpTransport::OPENDDS_MAP	(	PriorityKey	,
		UdpDataLink_rch
	)			[private]

Map of fully associated DataLinks for this transport. Protected.

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

Definition at line 252 of file UdpTransport.cpp.

References ACE_Guard< ACE_LOCK >::acquire(), blob_to_key(), config(), connections_lock_, OpenDDS::DCPS::find(), OpenDDS::DCPS::unique_ptr< T, Deleter >::get(), LM_DEBUG, OpenDDS::DCPS::WeakRcHandle< T >::lock(), pending_connections_, pending_server_link_keys_, ACE_Guard< ACE_LOCK >::release(), server_link_, server_link_keys_, OpenDDS::DCPS::static_rchandle_cast(), and VDBG.

{
  CORBA::ULong octet_size =
    static_cast<CORBA::ULong>(data->length() - sizeof(Priority));
  Priority priority;
  Serializer serializer(data.get());
  serializer >> priority;
  TransportBLOB blob(octet_size);
  blob.length(octet_size);
  serializer.read_octet_array(blob.get_buffer(), octet_size);

  // 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, config().local_address(), false /* passive */);

  ACE_Guard<ACE_Recursive_Thread_Mutex> guard(connections_lock_);

  //GuardType 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;
          RepoId 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);
  }
}

Here is the call graph for this function:

void OpenDDS::DCPS::UdpTransport::release_datalink

(

DataLink *

link

)

[protected, virtual]

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 214 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;
    }
  }
}

Here is the call graph for this function:

void OpenDDS::DCPS::UdpTransport::shutdown_i

(

)

[protected, virtual]

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 173 of file UdpTransport.cpp.

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

{
  // 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();
  }
}

Here is the call graph for this function:

void OpenDDS::DCPS::UdpTransport::stop_accepting_or_connecting	(	const TransportClient_wrch &	client,
		const RepoId &	remote_id
	)			[protected, virtual]

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 130 of file UdpTransport.cpp.

References connections_lock_, LM_DEBUG, pending_connections_, and VDBG.

{
  VDBG((LM_DEBUG, "(%P|%t) UdpTransport::stop_accepting_or_connecting\n"));

  //GuardType guard(connections_lock_);
  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;
    }
  }
}

virtual std::string OpenDDS::DCPS::UdpTransport::transport_type

(

)

const [inline, protected, virtual]

Implements OpenDDS::DCPS::TransportImpl.

Definition at line 56 of file UdpTransport.h.

{ return "udp"; }

---

Member Data Documentation

UdpDataLinkMap OpenDDS::DCPS::UdpTransport::client_links_ [private]

Definition at line 75 of file UdpTransport.h.

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

LockType OpenDDS::DCPS::UdpTransport::client_links_lock_ [private]

This lock is used to protect the client_links_ data member.

Definition at line 70 of file UdpTransport.h.

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

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 83 of file UdpTransport.h.

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

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.

Reimplemented from OpenDDS::DCPS::TransportImpl.

Definition at line 96 of file UdpTransport.h.

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

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 101 of file UdpTransport.h.

Referenced by accept_datalink(), and passive_connection().

UdpDataLink_rch OpenDDS::DCPS::UdpTransport::server_link_ [private]

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

Definition at line 78 of file UdpTransport.h.

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

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 89 of file UdpTransport.h.

Referenced by accept_datalink(), and passive_connection().

---

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

• UdpTransport.h
• UdpTransport.cpp