OpenDDS::DCPS::TcpDataLink Class Reference

#include <TcpDataLink.h>

Inheritance diagram for OpenDDS::DCPS::TcpDataLink:

[legend]

Collaboration diagram for OpenDDS::DCPS::TcpDataLink:

[legend]

List of all members.

Public Member Functions
	TcpDataLink (const ACE_INET_Addr &remote_address, TcpTransport &transport_impl, Priority priority, bool is_loopback, bool is_active)
virtual	~TcpDataLink ()
const ACE_INET_Addr &	remote_address () const
	Accessor for the remote address.
int	connect (const TcpConnection_rch &connection, const RcHandle< TcpSendStrategy > &send_strategy, const RcHandle< TcpReceiveStrategy > &receive_strategy)
int	reuse_existing_connection (const TcpConnection_rch &connection)
int	reconnect (const TcpConnection_rch &connection)
TcpConnection_rch	get_connection ()
virtual void	pre_stop_i ()
void	set_release_pending (bool flag)
	Set release pending flag.
bool	is_release_pending () const
	Get release pending flag.
void	ack_received (const ReceivedDataSample &sample)
void	request_ack_received (const ReceivedDataSample &sample)
void	drop_pending_request_acks ()
TcpSendStrategy_rch	send_strategy ()
TcpReceiveStrategy_rch	receive_strategy ()
Protected Member Functions
virtual void	stop_i ()
Private Member Functions
bool	handle_send_request_ack (TransportQueueElement *element)
void	send_graceful_disconnect_message ()
typedef	OPENDDS_VECTOR (TransportQueueElement *) PendingRequestAcks
Private Attributes
ACE_INET_Addr	remote_address_
WeakRcHandle< TcpConnection >	connection_
bool	graceful_disconnect_sent_
ACE_Atomic_Op < ACE_Thread_Mutex, bool >	release_is_pending_
ACE_SYNCH_MUTEX	pending_request_acks_lock_
PendingRequestAcks	pending_request_acks_

---

Detailed Description

Definition at line 24 of file TcpDataLink.h.

---

Constructor & Destructor Documentation

OPENDDS_BEGIN_VERSIONED_NAMESPACE_DECL OpenDDS::DCPS::TcpDataLink::TcpDataLink	(	const ACE_INET_Addr &	remote_address,
		TcpTransport &	transport_impl,
		Priority	priority,
		bool	is_loopback,
		bool	is_active
	)

Definition at line 25 of file TcpDataLink.cpp.

References DBG_ENTRY_LVL.

  : DataLink(transport_impl, priority, is_loopback, is_active),
    remote_address_(remote_address),
    graceful_disconnect_sent_(false),
    release_is_pending_(false)
{
  DBG_ENTRY_LVL("TcpDataLink","TcpDataLink",6);
}

OpenDDS::DCPS::TcpDataLink::~TcpDataLink

(

)

[virtual]

Definition at line 39 of file TcpDataLink.cpp.

References DBG_ENTRY_LVL.

{
  DBG_ENTRY_LVL("TcpDataLink","~TcpDataLink",6);
}

---

Member Function Documentation

void OpenDDS::DCPS::TcpDataLink::ack_received

(

const ReceivedDataSample &

sample

)

Definition at line 350 of file TcpDataLink.cpp.

References ACE_TEXT(), OpenDDS::DCPS::SequenceNumber::getValue(), OpenDDS::DCPS::ReceivedDataSample::header_, LM_DEBUG, OPENDDS_STRING, pending_request_acks_, pending_request_acks_lock_, OpenDDS::DCPS::DataSampleHeader::publication_id_, OpenDDS::DCPS::DataLink::send_strategy_, OpenDDS::DCPS::DataSampleHeader::sequence_, and OpenDDS::DCPS::Transport_debug_level.

{
  SequenceNumber sequence = sample.header_.sequence_;

  if (Transport_debug_level >= 1) {
    const GuidConverter converter(sample.header_.publication_id_);
    ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) TcpDataLink::ack_received() received sequence number %q, publiction_id=%C\n"),
      sequence.getValue(), OPENDDS_STRING(converter).c_str()));
  }

  TransportQueueElement* elem=0;
  {
    // find the pending request with the same sequence number.
    ACE_Guard<ACE_SYNCH_MUTEX> guard(pending_request_acks_lock_);
    PendingRequestAcks::iterator it;
    for (it = pending_request_acks_.begin(); it != pending_request_acks_.end(); ++it){
      if ((*it)->sequence() == sequence && (*it)->publication_id() == sample.header_.publication_id_) {
        elem = *it;
        pending_request_acks_.erase(it);
        break;
      }
    }
  }

  if (elem) {
    if (Transport_debug_level >= 1) {
      ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) TcpDataLink::ack_received() found matching element %@\n"),
        elem));
    }
    this->send_strategy_->deliver_ack_request(elem);
  }
  else {
    ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) TcpDataLink::ack_received() received unknown sequence number %q\n"),
      sequence.getValue()));
  }
}

Here is the call graph for this function:

int OpenDDS::DCPS::TcpDataLink::connect	(	const TcpConnection_rch &	connection,
		const RcHandle< TcpSendStrategy > &	send_strategy,
		const RcHandle< TcpReceiveStrategy > &	receive_strategy
	)

Called when an established connection object is available for this TcpDataLink. Called by the TcpTransport's connect_datalink() method.

The TcpTransport calls this method when it has an established connection object for us. This call puts this TcpDataLink into the "connected" state.

Definition at line 95 of file TcpDataLink.cpp.

References ACE_TEXT(), connection_, DBG_ENTRY_LVL, LM_ERROR, OpenDDS::DCPS::rchandle_from(), OpenDDS::DCPS::WeakRcHandle< T >::reset(), and OpenDDS::DCPS::DataLink::start().

Referenced by OpenDDS::DCPS::TcpTransport::connect_tcp_datalink().

{
  DBG_ENTRY_LVL("TcpDataLink","connect",6);

  this->connection_ = connection;

  if (connection->peer().enable(ACE_NONBLOCK) == -1) {
    ACE_ERROR_RETURN((LM_ERROR,
                      "(%P|%t) ERROR: TcpDataLink::connect failed to set "
                      "ACE_NONBLOCK %p\n", ACE_TEXT("enable")), -1);
  }

  // Let connection know the datalink for callbacks upon reconnect failure.
  connection->set_datalink(rchandle_from(this));

  // And lastly, inform our base class (DataLink) that we are now "connected",
  // and it should start the strategy objects.
  if (this->start(send_strategy, receive_strategy) != 0) {
    // Our base (DataLink) class failed to start the strategy objects.
    // We need to "undo" some things here before we return -1 to indicate
    // that an error has taken place.

    // Drop our reference to the connection object.
    this->connection_.reset();

    return -1;
  }

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void OpenDDS::DCPS::TcpDataLink::drop_pending_request_acks

(

)

Definition at line 429 of file TcpDataLink.cpp.

References pending_request_acks_, and pending_request_acks_lock_.

Referenced by OpenDDS::DCPS::TcpReceiveStrategy::reset(), and OpenDDS::DCPS::TcpReceiveStrategy::stop_i().

{
  ACE_Guard<ACE_SYNCH_MUTEX> guard(pending_request_acks_lock_);
  PendingRequestAcks::iterator it;
  for (it = pending_request_acks_.begin(); it != pending_request_acks_.end(); ++it){
    (*it)->data_dropped(true);
  }
  pending_request_acks_.clear();
}

Here is the caller graph for this function:

ACE_INLINE OpenDDS::DCPS::TcpConnection_rch OpenDDS::DCPS::TcpDataLink::get_connection

(

void

)

Definition at line 22 of file TcpDataLink.inl.

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

Referenced by OpenDDS::DCPS::TcpSendStrategy::get_handle(), OpenDDS::DCPS::TcpSynchResource::notify_lost_on_backpressure_timeout(), OpenDDS::DCPS::TcpReceiveStrategy::receive_bytes(), OpenDDS::DCPS::TcpSendStrategy::relink(), OpenDDS::DCPS::TcpReceiveStrategy::relink(), OpenDDS::DCPS::TcpSendStrategy::send_bytes_i(), and OpenDDS::DCPS::TcpReceiveStrategy::start_i().

{
  return this->connection_.lock();
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool OpenDDS::DCPS::TcpDataLink::handle_send_request_ack

(

TransportQueueElement *

element

)

[private, virtual]

Reimplemented from OpenDDS::DCPS::DataLink.

Definition at line 335 of file TcpDataLink.cpp.

References ACE_TEXT(), OpenDDS::DCPS::SequenceNumber::getValue(), LM_DEBUG, OPENDDS_STRING, pending_request_acks_, pending_request_acks_lock_, OpenDDS::DCPS::TransportQueueElement::publication_id(), OpenDDS::DCPS::TransportQueueElement::sequence(), and OpenDDS::DCPS::Transport_debug_level.

{
  if (Transport_debug_level >= 1) {
    const GuidConverter converter(element->publication_id());
    ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) TcpDataLink::handle_send_request_ack(%@) sequence number %q, publication_id=%C\n"),
      element, element->sequence().getValue(), OPENDDS_STRING(converter).c_str()));
  }

  ACE_Guard<ACE_SYNCH_MUTEX> guard(pending_request_acks_lock_);
  pending_request_acks_.push_back(element);
  return false;
}

Here is the call graph for this function:

bool OpenDDS::DCPS::TcpDataLink::is_release_pending

(

)

const

Get release pending flag.

Definition at line 329 of file TcpDataLink.cpp.

References release_is_pending_, and ACE_Atomic_Op_GCC< T >::value().

{
  return this->release_is_pending_.value();
}

Here is the call graph for this function:

typedef OpenDDS::DCPS::TcpDataLink::OPENDDS_VECTOR

(

TransportQueueElement *

)

[private]

void OpenDDS::DCPS::TcpDataLink::pre_stop_i

(

)

[virtual]

Called before release the datalink or before shutdown to let the concrete DataLink to do anything necessary.

Reimplemented from OpenDDS::DCPS::DataLink.

Definition at line 63 of file TcpDataLink.cpp.

References connection_, DBG_ENTRY_LVL, graceful_disconnect_sent_, OpenDDS::DCPS::DataLink::impl(), OpenDDS::DCPS::WeakRcHandle< T >::lock(), receive_strategy(), and send_graceful_disconnect_message().

{
  DBG_ENTRY_LVL("TcpDataLink","pre_stop_i",6);

  DataLink::pre_stop_i();

  TcpReceiveStrategy_rch rs = this->receive_strategy();

  TcpConnection_rch connection(this->connection_.lock());

  if (rs) {
    // If we received the GRACEFUL_DISCONNECT message from peer before we
    // initiate the disconnecting of the datalink, then we will not send
    // the GRACEFUL_DISCONNECT message to the peer.
    bool disconnected = rs->gracefully_disconnected();

    if (connection && !this->graceful_disconnect_sent_
        && !disconnected && !this->impl().is_shut_down()) {
      this->send_graceful_disconnect_message();
      this->graceful_disconnect_sent_ = true;
    }
  }

  if (connection) {
    connection->shutdown();
  }
}

Here is the call graph for this function:

OpenDDS::DCPS::TcpReceiveStrategy_rch OpenDDS::DCPS::TcpDataLink::receive_strategy

(

)

Definition at line 446 of file TcpDataLink.cpp.

References OpenDDS::DCPS::DataLink::receive_strategy_, and OpenDDS::DCPS::static_rchandle_cast().

Referenced by pre_stop_i().

{
  return static_rchandle_cast<OpenDDS::DCPS::TcpReceiveStrategy>(receive_strategy_);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int OpenDDS::DCPS::TcpDataLink::reconnect

(

const TcpConnection_rch &

connection

)

Associate the new connection object with this datalink object. The states of the "old" connection object are copied to the new connection object and the "old" connection object is replaced by the new connection object.

Definition at line 192 of file TcpDataLink.cpp.

References connection_, DBG_ENTRY_LVL, OpenDDS::DCPS::DataLink::impl(), OpenDDS::DCPS::RcHandle< T >::in(), OpenDDS::DCPS::RcHandle< T >::is_nil(), LM_ERROR, OpenDDS::DCPS::WeakRcHandle< T >::lock(), OpenDDS::DCPS::DataLink::receive_strategy_, OpenDDS::DCPS::TcpSendStrategy::reset(), OpenDDS::DCPS::TcpReceiveStrategy::reset(), OpenDDS::DCPS::DataLink::send_strategy_, OpenDDS::DCPS::DataLink::strategy_lock_, and VDBG_LVL.

{
  DBG_ENTRY_LVL("TcpDataLink","reconnect",6);

  TcpConnection_rch existing_connection(this->connection_.lock());
  // Sanity check - the connection should exist already since we are reconnecting.
  if (!existing_connection) {
    VDBG_LVL((LM_ERROR,
              "(%P|%t) ERROR: TcpDataLink::reconnect old connection is nil.\n")
             , 1);
    return -1;
  }

  existing_connection->transfer(connection.in());

  bool released = false;
  TransportStrategy_rch brs;
  TransportSendStrategy_rch bss;

  {
    GuardType guard2(this->strategy_lock_);

    if (this->receive_strategy_.is_nil() && this->send_strategy_.is_nil()) {
      released = true;

    } else {
      brs = this->receive_strategy_;
      bss = this->send_strategy_;
    }
  }

  if (released) {
    return static_cast<TcpTransport&>(impl()).connect_tcp_datalink(*this, connection);
  }

  this->connection_ = connection;

  TcpReceiveStrategy* rs = static_cast<TcpReceiveStrategy*>(brs.in());

  TcpSendStrategy* ss = static_cast<TcpSendStrategy*>(bss.in());

  // Associate the new connection object with the receiveing strategy and disassociate
  // the old connection object with the receiveing strategy.
  int rs_result = rs->reset(existing_connection.in(), connection.in());

  // Associate the new connection object with the sending strategy and disassociate
  // the old connection object with the sending strategy.
  int ss_result = ss->reset();

  if (rs_result == 0 && ss_result == 0) {
    return 0;
  }

  return -1;
}

Here is the call graph for this function:

OPENDDS_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE const ACE_INET_Addr & OpenDDS::DCPS::TcpDataLink::remote_address

(

)

const

Accessor for the remote address.

Definition at line 15 of file TcpDataLink.inl.

References DBG_ENTRY_LVL, and remote_address_.

Referenced by OpenDDS::DCPS::TcpTransport::release_datalink(), and OpenDDS::DCPS::TcpTransport::unbind_link().

{
  DBG_ENTRY_LVL("TcpDataLink","remote_address",6);
  return this->remote_address_;
}

Here is the caller graph for this function:

void OpenDDS::DCPS::TcpDataLink::request_ack_received

(

const ReceivedDataSample &

sample

)

Definition at line 388 of file TcpDataLink.cpp.

References OpenDDS::DCPS::DataSampleHeader::byte_order_, OpenDDS::DCPS::ReceivedDataSample::header_, OpenDDS::DCPS::DataSampleHeader::max_marshaled_size(), ACE_Time_Value::max_time, ACE_Message_Block::MB_DATA, OpenDDS::DCPS::DataSampleHeader::message_id_, OpenDDS::DCPS::DataSampleHeader::message_length_, OpenDDS::DCPS::move(), OpenDDS::DCPS::DataSampleHeader::publication_id_, OpenDDS::DCPS::DataSampleHeader::publisher_id_, OpenDDS::DCPS::SAMPLE_ACK, OpenDDS::DCPS::DataLink::send_i(), OpenDDS::DCPS::DataSampleHeader::sequence_, and ACE_Time_Value::zero.

{
  DataSampleHeader header_data;
  // The message_id_ is the most important value for the DataSampleHeader.
  header_data.message_id_ = SAMPLE_ACK;

  // Other data in the DataSampleHeader are not necessary set. The bogus values
  // can be used.

  header_data.byte_order_  = ACE_CDR_BYTE_ORDER;
  header_data.message_length_ = 0;
  header_data.sequence_ = sample.header_.sequence_;
  header_data.publication_id_ = sample.header_.publication_id_;
  header_data.publisher_id_ = sample.header_.publisher_id_;

  size_t max_marshaled_size = header_data.max_marshaled_size();

  Message_Block_Ptr message(
    new ACE_Message_Block(max_marshaled_size,
                          ACE_Message_Block::MB_DATA,
                          0, //cont
                          0, //data
                          0, //allocator_strategy
                          0, //locking_strategy
                          ACE_DEFAULT_MESSAGE_BLOCK_PRIORITY,
                          ACE_Time_Value::zero,
                          ACE_Time_Value::max_time,
                          0,
                          0));

  *message << header_data;

  TransportControlElement* send_element =  new TransportControlElement(move(message));


  // I don't want to rebuild a connection in order to send
  // a sample ack message
  this->send_i(send_element, false);
}

Here is the call graph for this function:

int OpenDDS::DCPS::TcpDataLink::reuse_existing_connection

(

const TcpConnection_rch &

connection

)

Definition at line 136 of file TcpDataLink.cpp.

References connection_, DBG_ENTRY_LVL, OpenDDS::DCPS::RcHandle< T >::in(), OpenDDS::DCPS::DataLink::is_active_, OpenDDS::DCPS::RcHandle< T >::is_nil(), LM_DEBUG, OpenDDS::DCPS::WeakRcHandle< T >::lock(), OpenDDS::DCPS::DataLink::receive_strategy_, OpenDDS::DCPS::TcpSendStrategy::reset(), OpenDDS::DCPS::TcpReceiveStrategy::reset(), OpenDDS::DCPS::DataLink::send_strategy_, and VDBG_LVL.

Referenced by OpenDDS::DCPS::TcpTransport::connect_tcp_datalink().

{
  DBG_ENTRY_LVL("TcpDataLink","reuse_existing_connection",6);

  if (this->is_active_) {
    return -1;
  }
  //Need to check if connection is nil.  If connection is not nil, then connection
  //has previously gone through connection phase so this is a reuse of the connection
  //proceed to determine if we can reuse/reset existing mechanisms or need to start from
  //scratch.

  TcpConnection_rch old_connection(this->connection_.lock());

  if (old_connection) {
    VDBG_LVL((LM_DEBUG, "(%P|%t) TcpDataLink::reuse_existing_connection - "
                           "trying to reuse existing connection\n"), 0);
    old_connection->transfer(connection.in());

    //Connection already exists.
    TransportStrategy_rch brs;
    TransportSendStrategy_rch bss;

    if (this->receive_strategy_.is_nil() && this->send_strategy_.is_nil()) {
      return -1;
    } else {
      brs = this->receive_strategy_;
      bss = this->send_strategy_;

      this->connection_ = connection;

      TcpReceiveStrategy* rs = static_cast<TcpReceiveStrategy*>(brs.in());

      TcpSendStrategy* ss = static_cast<TcpSendStrategy*>(bss.in());

      // Associate the new connection object with the receiving strategy and disassociate
      // the old connection object with the receiving strategy.
      int rs_result = rs->reset(0, connection.in());

      // Associate the new connection object with the sending strategy and disassociate
      // the old connection object with the sending strategy.
      int ss_result = ss->reset(true);

      if (rs_result == 0 && ss_result == 0) {
        return 0;
      }
    }
  }
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void OpenDDS::DCPS::TcpDataLink::send_graceful_disconnect_message

(

)

[private]

Definition at line 249 of file TcpDataLink.cpp.

References DBG_ENTRY_LVL, OpenDDS::DCPS::GRACEFUL_DISCONNECT, OpenDDS::DCPS::DataSampleHeader::max_marshaled_size(), ACE_Time_Value::max_time, ACE_Message_Block::MB_DATA, OpenDDS::DCPS::DataSampleHeader::message_id_, OpenDDS::DCPS::DataSampleHeader::message_length_, OpenDDS::DCPS::move(), OpenDDS::DCPS::unique_ptr< T, Deleter >::release(), OpenDDS::DCPS::DataLink::send_i(), OpenDDS::DCPS::DataLink::send_strategy_, and ACE_Time_Value::zero.

Referenced by pre_stop_i().

{
  DBG_ENTRY_LVL("TcpDataLink","send_graceful_disconnect_message",6);

  // Will clear all queued messages but still let the disconnect message
  // sent.
  this->send_strategy_->terminate_send(true);

  DataSampleHeader header_data;
  // The message_id_ is the most important value for the DataSampleHeader.
  header_data.message_id_ = GRACEFUL_DISCONNECT;

  // Other data in the DataSampleHeader are not necessary set. The bogus values
  // can be used.

  //header_data.byte_order_
  //  = this->transport_->config()->swap_bytes() ? !TAO_ENCAP_BYTE_ORDER : TAO_ENCAP_BYTE_ORDER;
  //header_data.message_length_ = 0;
  //header_data.sequence_ = 0;
  //DDS::Time_t source_timestamp
  //  = OpenDDS::DCPS::time_value_to_time (ACE_OS::gettimeofday ());
  //header_data.source_timestamp_sec_ = source_timestamp.sec;
  //header_data.source_timestamp_nanosec_ = source_timestamp.nanosec;
  //header_data.coherency_group_ = 0;
  //header_data.publication_id_ = 0;

  // TODO:
  // It seems a bug in the transport implementation that the receiving side can
  // not receive the message when the message has no sample data and is sent
  // in a single packet.

  // To work arround this problem, I have to add bogus data to chain with the
  // DataSampleHeader to make the receiving work.
  size_t max_marshaled_size = header_data.max_marshaled_size();

  Message_Block_Ptr data(
    new ACE_Message_Block(20,
                          ACE_Message_Block::MB_DATA,
                          0, //cont
                          0, //data
                          0, //allocator_strategy
                          0, //locking_strategy
                          ACE_DEFAULT_MESSAGE_BLOCK_PRIORITY,
                          ACE_Time_Value::zero,
                          ACE_Time_Value::max_time,
                          0,
                          0));
  data->wr_ptr(20);

  header_data.message_length_ = static_cast<ACE_UINT32>(data->length());

  Message_Block_Ptr message(
    new ACE_Message_Block(max_marshaled_size,
                          ACE_Message_Block::MB_DATA,
                          data.release(), //cont
                          0, //data
                          0, //allocator_strategy
                          0, //locking_strategy
                          ACE_DEFAULT_MESSAGE_BLOCK_PRIORITY,
                          ACE_Time_Value::zero,
                          ACE_Time_Value::max_time,
                          0,
                          0));

  *message << header_data;

  TransportControlElement* send_element = new TransportControlElement(move(message));

  // I don't want to rebuild a connection in order to send
  // a graceful disconnect message.
  this->send_i(send_element, false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

OpenDDS::DCPS::TcpSendStrategy_rch OpenDDS::DCPS::TcpDataLink::send_strategy

(

)

Definition at line 440 of file TcpDataLink.cpp.

References OpenDDS::DCPS::DataLink::send_strategy_, and OpenDDS::DCPS::static_rchandle_cast().

{
  return static_rchandle_cast<OpenDDS::DCPS::TcpSendStrategy>(send_strategy_);
}

Here is the call graph for this function:

void OpenDDS::DCPS::TcpDataLink::set_release_pending

(

bool

flag

)

Set release pending flag.

Definition at line 323 of file TcpDataLink.cpp.

References release_is_pending_.

{
  this->release_is_pending_ = flag;
}

void OpenDDS::DCPS::TcpDataLink::stop_i

(

)

[protected, virtual]

Called when the DataLink is self-releasing because all of its reservations have been released, or when the TransportImpl is handling a shutdown() call.

Called when the DataLink has been "stopped" for some reason. It could be called from the DataLink::transport_shutdown() method (when the TransportImpl is handling a shutdown() call). Or, it could be called from the DataLink::release_reservations() method, when it discovers that it has just released the last remaining reservations from the DataLink, and the DataLink is in the process of "releasing" itself.

Reimplemented from OpenDDS::DCPS::DataLink.

Definition at line 51 of file TcpDataLink.cpp.

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

{
  DBG_ENTRY_LVL("TcpDataLink","stop_i",6);

  TcpConnection_rch connection(this->connection_.lock());
  if (connection) {
    // Tell the connection object to disconnect.
    connection->disconnect();
  }
}

Here is the call graph for this function:

---

Member Data Documentation

WeakRcHandle<TcpConnection> OpenDDS::DCPS::TcpDataLink::connection_ [private]

Definition at line 75 of file TcpDataLink.h.

Referenced by connect(), get_connection(), pre_stop_i(), reconnect(), reuse_existing_connection(), and stop_i().

bool OpenDDS::DCPS::TcpDataLink::graceful_disconnect_sent_ [private]

Definition at line 76 of file TcpDataLink.h.

Referenced by pre_stop_i().

PendingRequestAcks OpenDDS::DCPS::TcpDataLink::pending_request_acks_ [private]

Definition at line 80 of file TcpDataLink.h.

Referenced by ack_received(), drop_pending_request_acks(), and handle_send_request_ack().

ACE_SYNCH_MUTEX OpenDDS::DCPS::TcpDataLink::pending_request_acks_lock_ [private]

Definition at line 79 of file TcpDataLink.h.

Referenced by ack_received(), drop_pending_request_acks(), and handle_send_request_ack().

ACE_Atomic_Op<ACE_Thread_Mutex, bool> OpenDDS::DCPS::TcpDataLink::release_is_pending_ [private]

Definition at line 77 of file TcpDataLink.h.

Referenced by is_release_pending(), and set_release_pending().

ACE_INET_Addr OpenDDS::DCPS::TcpDataLink::remote_address_ [private]

Definition at line 74 of file TcpDataLink.h.

Referenced by remote_address().

---

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

• TcpDataLink.h
• TcpDataLink.cpp
• TcpDataLink.inl