OpenDDS::DCPS::RtpsUdpSendStrategy Class Reference

#include <RtpsUdpSendStrategy.h>

Inheritance diagram for OpenDDS::DCPS::RtpsUdpSendStrategy:

Collaboration diagram for OpenDDS::DCPS::RtpsUdpSendStrategy:

Classes
struct	Chunk
struct	OverrideToken

Public Member Functions
	RtpsUdpSendStrategy (RtpsUdpDataLink *link, const GuidPrefix_t &local_prefix)
virtual void	stop_i ()
	Let the subclass stop. More...
OverrideToken	override_destinations (const NetworkAddress &destination)
OverrideToken	override_destinations (const AddrSet &destinations)
void	send_rtps_control (RTPS::Message &message, ACE_Message_Block &submessages, const NetworkAddress &destination)
void	send_rtps_control (RTPS::Message &message, ACE_Message_Block &submessages, const AddrSet &destinations)
void	append_submessages (const RTPS::SubmessageSeq &submessages)
void	encode_payload (const GUID_t &pub_id, Message_Block_Ptr &payload, RTPS::SubmessageSeq &submessages)
virtual Security::SecurityConfig_rch	security_config () const
Public Member Functions inherited from OpenDDS::DCPS::TransportSendStrategy
virtual	~TransportSendStrategy ()
void	send_buffer (TransportSendBuffer *send_buffer)
	Assigns an optional send buffer. More...
int	start ()
void	stop ()
void	send_start ()
void	send (TransportQueueElement *element, bool relink=true)
void	send_stop (GUID_t repoId)
RemoveResult	remove_sample (const DataSampleElement *sample)
void	remove_all_msgs (const GUID_t &pub_id)
virtual WorkOutcome	perform_work ()
virtual void	relink (bool do_suspend=true)
void	suspend_send ()
void	resume_send ()
void	terminate_send (bool graceful_disconnecting=false)
	Remove all samples in the backpressure queue and packet queue. More...
virtual void	terminate_send_if_suspended ()
virtual bool	start_i ()
	Let the subclass start. More...
void	link_released (bool flag)
bool	isDirectMode ()
virtual ACE_HANDLE	get_handle ()
void	deliver_ack_request (TransportQueueElement *element)
bool	fragmentation_helper (TransportQueueElement *original_element, TqeVector &elements_to_send)
void	clear (SendMode new_mode, SendMode old_mode=MODE_NOT_SET)
SendMode	mode () const
	Access the current sending mode. More...
Public Member Functions inherited from OpenDDS::DCPS::ThreadSynchWorker
virtual	~ThreadSynchWorker ()
virtual void	schedule_output ()
	Indicate that queued data is available to be sent. More...
std::size_t	id () const
	DataLink reference value for diagnostics. More...
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

Static Public Attributes
static const size_t	MaxCryptoHeaderSize = 20
static const size_t	MaxCryptoFooterSize = 20
static const size_t	MaxSecurePrefixSize = RTPS::SMHDR_SZ + MaxCryptoHeaderSize
static const size_t	MaxSubmessagePadding = RTPS::SM_ALIGN - 1
static const size_t	MaxSecureSuffixSize = RTPS::SMHDR_SZ + MaxCryptoFooterSize
static const size_t	MaxSecureSubmessageLeadingSize = MaxSecurePrefixSize
static const size_t	MaxSecureSubmessageFollowingSize
static const size_t	MaxSecureSubmessageAdditionalSize
static const size_t	MaxSecureFullMessageLeadingSize
static const size_t	MaxSecureFullMessageFollowingSize = MaxSecureSuffixSize
static const size_t	MaxSecureFullMessageAdditionalSize
Static Public Attributes inherited from OpenDDS::DCPS::TransportSendStrategy
static const size_t	UDP_MAX_MESSAGE_SIZE = 65466

Protected Member Functions
virtual ssize_t	send_bytes_i (const iovec iov[], int n)
ssize_t	send_bytes_i_helper (const iovec iov[], int n)
virtual size_t	max_message_size () const
virtual void	add_delayed_notification (TransportQueueElement *element)
Protected Member Functions inherited from OpenDDS::DCPS::TransportSendStrategy
	TransportSendStrategy (std::size_t id, const TransportImpl_rch &transport, ThreadSynchResource *synch_resource, Priority priority, const ThreadSynchStrategy_rch &thread_sync_strategy)
virtual ssize_t	send_bytes (const iovec iov[], int n, int &bp)
virtual ssize_t	non_blocking_send (const iovec iov[], int n, int &bp)
virtual void	prepare_header_i ()
	Specific implementation processing of prepared packet header. More...
virtual void	prepare_packet_i ()
	Specific implementation processing of prepared packet. More...
TransportQueueElement *	current_packet_first_element () const
void	set_graceful_disconnecting (bool flag)
	Set graceful disconnecting flag. More...
bool	send_delayed_notifications (const TransportQueueElement::MatchCriteria *match=0)
virtual RemoveResult	do_remove_sample (const GUID_t &pub_id, const TransportQueueElement::MatchCriteria &criteria, bool remove_all=false)
	Implement framework chain visitations to remove a sample. More...
ThreadSynch *	synch () const
void	set_header_source (ACE_INT64 source)
Protected Member Functions inherited from OpenDDS::DCPS::ThreadSynchWorker
	ThreadSynchWorker (std::size_t id=0)
Protected Member Functions inherited from OpenDDS::DCPS::RcObject
	RcObject ()

Private Member Functions
bool	marshal_transport_header (ACE_Message_Block *mb)
ssize_t	send_multi_i (const iovec iov[], int n, const AddrSet &addrs)
const ACE_SOCK_Dgram &	choose_send_socket (const NetworkAddress &addr) const
ssize_t	send_single_i (const iovec iov[], int n, const NetworkAddress &addr)
ACE_Message_Block *	pre_send_packet (const ACE_Message_Block *plain)
bool	encode_writer_submessage (const GUID_t &sender, const GUID_t &receiver, OPENDDS_VECTOR(Chunk)&replacements, DDS::Security::CryptoTransform *crypto, const DDS::OctetSeq &plain, DDS::Security::DatawriterCryptoHandle sender_dwch, const char *submessage_start, CORBA::Octet msgId)
bool	encode_reader_submessage (const GUID_t &sender, const GUID_t &receiver, OPENDDS_VECTOR(Chunk)&replacements, DDS::Security::CryptoTransform *crypto, const DDS::OctetSeq &plain, DDS::Security::DatareaderCryptoHandle sender_drch, const char *submessage_start, CORBA::Octet msgId)
ACE_Message_Block *	encode_submessages (const ACE_Message_Block *plain, DDS::Security::CryptoTransform *crypto, bool &stateless_or_volatile)
ACE_Message_Block *	encode_rtps_message (const ACE_Message_Block *plain, DDS::Security::CryptoTransform *crypto)
ACE_Message_Block *	replace_chunks (const ACE_Message_Block *plain, const OPENDDS_VECTOR(Chunk)&replacements)

Private Attributes
RtpsUdpDataLink *	link_
const AddrSet *	override_dest_
const NetworkAddress *	override_single_dest_
const size_t	max_message_size_
RTPS::Message	rtps_message_
ACE_Thread_Mutex	rtps_message_mutex_
char	rtps_header_data_ [RTPS::RTPSHDR_SZ]
ACE_Data_Block	rtps_header_db_
ACE_Message_Block	rtps_header_mb_
ACE_Thread_Mutex	rtps_header_mb_lock_
AtomicBool	network_is_unreachable_

Friends
struct	OverrideToken

Additional Inherited Members
Public Types inherited from OpenDDS::DCPS::TransportSendStrategy
enum	SendMode {   MODE_NOT_SET, MODE_DIRECT, MODE_QUEUE, MODE_SUSPEND,   MODE_TERMINATED }
typedef BasicQueue< TransportQueueElement >	QueueType
Public Types inherited from OpenDDS::DCPS::ThreadSynchWorker
enum	WorkOutcome { WORK_OUTCOME_MORE_TO_DO, WORK_OUTCOME_NO_MORE_TO_DO, WORK_OUTCOME_CLOGGED_RESOURCE, WORK_OUTCOME_BROKEN_RESOURCE }
Static Public Member Functions inherited from OpenDDS::DCPS::TransportSendStrategy
static int	mb_to_iov (const ACE_Message_Block &msg, iovec *iov)

Detailed Description

Definition at line 30 of file RtpsUdpSendStrategy.h.

Constructor & Destructor Documentation

RtpsUdpSendStrategy()

OpenDDS::DCPS::RtpsUdpSendStrategy::RtpsUdpSendStrategy	(	RtpsUdpDataLink *	link,
		const GuidPrefix_t &	local_prefix
	)

Definition at line 34 of file RtpsUdpSendStrategy.cpp.

References code, EADDRNOTAVAIL, ENETUNREACH, ENOBUFS, EPERM, OpenDDS::RTPS::Header::guidPrefix, OpenDDS::RTPS::Message::hdr, OpenDDS::RTPS::Header::prefix, OpenDDS::RTPS::PROTOCOL_RTPS, OpenDDS::RTPS::PROTOCOLVERSION, rtps_header_mb_, rtps_message_, OpenDDS::RTPS::Header::vendorId, OpenDDS::RTPS::VENDORID_OPENDDS, and OpenDDS::RTPS::Header::version.

  : TransportSendStrategy(0, link->impl(),
                          0,  // synch_resource
                          link->transport_priority(),
                          make_rch<NullSynchStrategy>()),
    link_(link),
    override_dest_(0),
    override_single_dest_(0),
    max_message_size_(link->config()->max_message_size_),
    rtps_header_db_(RTPS::RTPSHDR_SZ, ACE_Message_Block::MB_DATA,
                    rtps_header_data_, 0, 0, ACE_Message_Block::DONT_DELETE, 0),
    rtps_header_mb_(&rtps_header_db_, ACE_Message_Block::DONT_DELETE),
    network_is_unreachable_(false)
{
  std::memcpy(rtps_message_.hdr.prefix, RTPS::PROTOCOL_RTPS, sizeof RTPS::PROTOCOL_RTPS);
  rtps_message_.hdr.version = OpenDDS::RTPS::PROTOCOLVERSION;
  rtps_message_.hdr.vendorId = OpenDDS::RTPS::VENDORID_OPENDDS;
  std::memcpy(rtps_message_.hdr.guidPrefix, local_prefix,
              sizeof(GuidPrefix_t));
  Serializer writer(&rtps_header_mb_, encoding_unaligned_native);
  // byte order doesn't matter for the RTPS Header
  writer << rtps_message_.hdr;
}

Member Function Documentation

add_delayed_notification()

void OpenDDS::DCPS::RtpsUdpSendStrategy::add_delayed_notification ( TransportQueueElement *  element )

protectedvirtual

Reimplemented from OpenDDS::DCPS::TransportSendStrategy.

Definition at line 356 of file RtpsUdpSendStrategy.cpp.

References OpenDDS::DCPS::RtpsUdpDataLink::add_delayed_notification(), OpenDDS::DCPS::TransportSendStrategy::add_delayed_notification(), ACE_Message_Block::cont(), ACE_Message_Block::length(), link_, ACE_Message_Block::rd_ptr(), and ACE_Message_Block::total_length().

{
  if (!link_->add_delayed_notification(element)) {
    TransportSendStrategy::add_delayed_notification(element);
  }
}

append_submessages()

void OpenDDS::DCPS::RtpsUdpSendStrategy::append_submessages

(

const RTPS::SubmessageSeq &

submessages

)

Definition at line 241 of file RtpsUdpSendStrategy.cpp.

References ACE_GUARD, OpenDDS::DCPS::push_back(), rtps_message_, rtps_message_mutex_, and OpenDDS::RTPS::Message::submessages.

{
  ACE_GUARD(ACE_Thread_Mutex, g, rtps_message_mutex_);
  for (ACE_CDR::ULong idx = 0; idx != submessages.length(); ++idx) {
    DCPS::push_back(rtps_message_.submessages, submessages[idx]);
  }
}

choose_send_socket()

const ACE_SOCK_Dgram & OpenDDS::DCPS::RtpsUdpSendStrategy::choose_send_socket ( const NetworkAddress &  addr ) const

private

Definition at line 268 of file RtpsUdpSendStrategy.cpp.

References OpenDDS::DCPS::NetworkAddress::get_type(), link_, and OpenDDS::DCPS::RtpsUdpDataLink::unicast_socket().

Referenced by send_single_i().

{
#ifdef ACE_HAS_IPV6
  if (addr.get_type() == AF_INET6) {
    return link_->ipv6_unicast_socket();
  }
#endif
  ACE_UNUSED_ARG(addr);
  return link_->unicast_socket();
}

encode_payload()

void OpenDDS::DCPS::RtpsUdpSendStrategy::encode_payload	(	const GUID_t &	pub_id,
		Message_Block_Ptr &	payload,
		RTPS::SubmessageSeq &	submessages
	)

Definition at line 385 of file RtpsUdpSendStrategy.cpp.

References ACE_CDR_BYTE_ORDER, ACE_Message_Block::copy(), OpenDDS::RTPS::DATA, OpenDDS::RTPS::FLAG_N_IN_DATA, OpenDDS::RTPS::FLAG_Q, OpenDDS::RTPS::SubmessageHeader::flags, OpenDDS::DCPS::unique_ptr< T, Deleter >::get(), DDS::HANDLE_NIL, OpenDDS::DCPS::RtpsUdpDataLink::handle_registry(), OpenDDS::RTPS::DataSubmessage::inlineQos, OpenDDS::DCPS::Encoding::KIND_XCDR1, link_, LM_WARNING, OpenDDS::DCPS::unique_ptr< T, Deleter >::reset(), OpenDDS::DCPS::RtpsUdpDataLink::security_config(), OpenDDS::RTPS::DataSubmessage::smHeader, and VDBG_LVL.

{
  const DDS::Security::DatawriterCryptoHandle writer_crypto_handle =
    link_->handle_registry()->get_local_datawriter_crypto_handle(pub_id);
  DDS::Security::CryptoTransform_var crypto =
    link_->security_config()->get_crypto_transform();

  if (writer_crypto_handle == DDS::HANDLE_NIL || !crypto) {
    return;
  }

  const DDS::OctetSeq plain = toSeq(payload.get());
  DDS::OctetSeq encoded, iQos;
  DDS::Security::SecurityException ex = {"", 0, 0};

  if (crypto->encode_serialized_payload(encoded, iQos, plain, writer_crypto_handle, ex)) {
    if (encoded != plain) {
      payload.reset(new ACE_Message_Block(encoded.length()));
      const char* raw = reinterpret_cast<const char*>(encoded.get_buffer());
      payload->copy(raw, encoded.length());

      // Set FLAG_N flag
      for (CORBA::ULong i = 0; i < submessages.length(); ++i) {
          if (submessages[i]._d() == RTPS::DATA) {
              RTPS::DataSubmessage& data = submessages[i].data_sm();
              data.smHeader.flags |= RTPS::FLAG_N_IN_DATA;
          }
      }
    }

    const CORBA::ULong iQosLen = iQos.length();
    if (iQosLen > 3) {
      for (CORBA::ULong i = 0; i < submessages.length(); ++i) {
        if (submessages[i]._d() == RTPS::DATA) {
          // ParameterList must end in {1, 0, x, x} (LE) or {0, 1, x, x} (BE)
          // Check for this sentinel and use it for endianness detection
          if (iQos[iQosLen - 3] + iQos[iQosLen - 4] != 1) {
            VDBG_LVL((LM_WARNING, "(%P|%t) RtpsUdpSendStrategy::encode_payload "
                      "extra_inline_qos is not a valid ParameterList\n"), 2);
            break;
          }

          const bool swapPl = iQos[iQosLen - 4] != ACE_CDR_BYTE_ORDER;
          const char* rawIQos = reinterpret_cast<const char*>(iQos.get_buffer());
          ACE_Message_Block mbIQos(rawIQos, iQosLen);
          Serializer ser(&mbIQos, Encoding::KIND_XCDR1, swapPl);

          RTPS::DataSubmessage& data = submessages[i].data_sm();
          if (!(ser >> data.inlineQos)) { // appends to any existing inlineQos
            VDBG_LVL((LM_WARNING, "(%P|%t) RtpsUdpSendStrategy::encode_payload "
                      "extra_inline_qos deserialization failed\n"), 2);
            break;
          }
          data.smHeader.flags |= RTPS::FLAG_Q;
          break;
        }
      }
    } else if (iQosLen) {
      VDBG_LVL((LM_WARNING, "(%P|%t) RtpsUdpSendStrategy::encode_payload "
                "extra_inline_qos not enough bytes for ParameterList\n"), 2);
    }
  }
}

encode_reader_submessage()

bool OpenDDS::DCPS::RtpsUdpSendStrategy::encode_reader_submessage ( const GUID_t &  sender, const GUID_t &  receiver, OPENDDS_VECTOR(Chunk)&  replacements, DDS::Security::CryptoTransform *  crypto, const DDS::OctetSeq &  plain, DDS::Security::DatareaderCryptoHandle  sender_drch, const char *  submessage_start, CORBA::Octet  msgId  )

private

Definition at line 590 of file RtpsUdpSendStrategy.cpp.

References DDS::Security::CryptoTransform::encode_datareader_submessage(), OpenDDS::DCPS::RtpsUdpSendStrategy::Chunk::encoded_, OpenDDS::DCPS::GUID_UNKNOWN, DDS::HANDLE_NIL, OpenDDS::DCPS::RtpsUdpDataLink::handle_registry(), OpenDDS::DCPS::RtpsUdpSendStrategy::Chunk::length_, link_, and OpenDDS::DCPS::RtpsUdpSendStrategy::Chunk::start_.

Referenced by encode_submessages().

{
  using namespace DDS::Security;

  if (sender_drch == DDS::HANDLE_NIL) {
    return true;
  }

  DatawriterCryptoHandle dwch = DDS::HANDLE_NIL;
  DatawriterCryptoHandleSeq writerHandles;
  if (std::memcmp(&GUID_UNKNOWN, &receiver, sizeof receiver)) {
    dwch = link_->handle_registry()->get_remote_datawriter_crypto_handle(receiver);
    if (dwch != DDS::HANDLE_NIL) {
      writerHandles.length(1);
      writerHandles[0] = dwch;
    }
  }

  SecurityException ex = {"", 0, 0};
  replacements.resize(replacements.size() + 1);
  Chunk& c = replacements.back();
  if (crypto->encode_datareader_submessage(c.encoded_, plain, sender_drch, writerHandles, ex)) {
    if (c.encoded_ != plain) {
      c.start_ = submessage_start;
      c.length_ = plain.length();
    } else {
      replacements.pop_back();
    }
  } else {
    log_encode_error(msgId, sender_drch, sender, dwch, receiver, ex);
    replacements.pop_back();
    return false;
  }
  return true;
}

encode_rtps_message()

ACE_Message_Block * OpenDDS::DCPS::RtpsUdpSendStrategy::encode_rtps_message ( const ACE_Message_Block *  plain, DDS::Security::CryptoTransform *  crypto  )

private

Definition at line 470 of file RtpsUdpSendStrategy.cpp.

References ACE_ERROR, DDS::Security::SecurityException::code, ACE_Message_Block::copy(), OpenDDS::RTPS::DATA, OpenDDS::RTPS::DATA_FRAG, ACE_Message_Block::duplicate(), DDS::Security::CryptoTransform::encode_rtps_message(), OpenDDS::DCPS::Serializer::encoding(), OpenDDS::RTPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_WRITER, OpenDDS::RTPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER, OpenDDS::RTPS::SubmessageHeader::flags, OpenDDS::RTPS::INFO_TS, link_, LM_ERROR, OpenDDS::DCPS::RtpsUdpDataLink::local_crypto_handle(), DDS::Security::SecurityException::message, DDS::Security::SecurityException::minor_code, OpenDDS::RTPS::PAD, OpenDDS::DCPS::Serializer::read_octet_array(), OpenDDS::DCPS::unique_ptr< T, Deleter >::release(), OpenDDS::RTPS::SMHDR_SZ, ACE_Message_Block::space(), OpenDDS::RTPS::SubmessageHeader::submessageId, OpenDDS::RTPS::SubmessageHeader::submessageLength, OpenDDS::DCPS::Transport_debug_level, and ACE_Message_Block::wr_ptr().

Referenced by pre_send_packet().

{
  using namespace DDS::Security;
  DDS::OctetSeq encoded_rtps_message;
  const DDS::OctetSeq plain_rtps_message = toSeq(plain);
  const ParticipantCryptoHandle send_handle = link_->local_crypto_handle();
  const ParticipantCryptoHandleSeq recv_handles; // unused
  int idx = 0; // unused
  SecurityException ex = {"", 0, 0};
  if (crypto->encode_rtps_message(encoded_rtps_message, plain_rtps_message,
                                  send_handle, recv_handles, idx, ex)) {
    Message_Block_Ptr out(new ACE_Message_Block(encoded_rtps_message.length()));
    const char* raw = reinterpret_cast<const char*>(encoded_rtps_message.get_buffer());
    out->copy(raw, encoded_rtps_message.length());
    return out.release();
  }
  if (ex.code == 0 && ex.minor_code == 0) {
    return plain->duplicate(); // send original pre-encoded msg
  }
  if (Transport_debug_level) {
    ACE_ERROR((LM_ERROR, "RtpsUdpSendStrategy::encode_rtps_message - ERROR "
               "plugin failed to encode RTPS message from handle %d [%d.%d]: %C\n",
               send_handle, ex.code, ex.minor_code, ex.message.in()));
  }
  return 0; // do not send pre-encoded msg
}

encode_submessages()

ACE_Message_Block * OpenDDS::DCPS::RtpsUdpSendStrategy::encode_submessages ( const ACE_Message_Block *  plain, DDS::Security::CryptoTransform *  crypto, bool &  stateless_or_volatile  )

private

Definition at line 634 of file RtpsUdpSendStrategy.cpp.

References OpenDDS::RTPS::ACKNACK, OpenDDS::DCPS::assign(), OpenDDS::RTPS::MessageParser::current(), OpenDDS::RTPS::DATA, OpenDDS::RTPS::DATA_FRAG, ACE_Message_Block::duplicate(), encode_reader_submessage(), encode_writer_submessage(), OpenDDS::DCPS::GUID_t::entityId, OpenDDS::RTPS::GAP, OpenDDS::DCPS::GUID_UNKNOWN, OpenDDS::DCPS::GUID_t::guidPrefix, OpenDDS::DCPS::RtpsUdpDataLink::handle_registry(), OpenDDS::RTPS::MessageParser::hasNextSubmessage(), OpenDDS::RTPS::HEARTBEAT, OpenDDS::RTPS::HEARTBEAT_FRAG, OpenDDS::RTPS::INFO_DST, link_, OpenDDS::DCPS::RtpsUdpDataLink::local_prefix(), OpenDDS::RTPS::NACK_FRAG, OpenDDS::DCPS::TransportSendStrategy::OPENDDS_VECTOR(), OpenDDS::RTPS::MessageParser::parseHeader(), OpenDDS::RTPS::MessageParser::parseSubmessageHeader(), OpenDDS::RTPS::MessageParser::remaining(), replace_chunks(), OpenDDS::RTPS::MessageParser::serializer(), OpenDDS::RTPS::MessageParser::skipToNextSubmessage(), OpenDDS::RTPS::MessageParser::submessageHeader(), and OpenDDS::RTPS::SubmessageHeader::submessageId.

Referenced by pre_send_packet().

{
  // 'plain' contains a full RTPS Message on its way to the socket(s).
  // Let the crypto plugin examine each submessage and replace it with an
  // encoded version.  First, parse through the message using the 'plain'
  // message block chain.  Instead of changing the messsage in place,
  // modifications are stored in the 'replacements' which will end up
  // changing the message when the 'out' message block is created in the
  // helper method replace_chunks().
  RTPS::MessageParser parser(*plain);
  bool ok = parser.parseHeader();

  GUID_t sender = GUID_UNKNOWN;
  assign(sender.guidPrefix, link_->local_prefix());

  GUID_t receiver = GUID_UNKNOWN;

  OPENDDS_VECTOR(Chunk) replacements;

  while (ok && parser.remaining()) {

    const char* const submessage_start = parser.current();

    if (!parser.parseSubmessageHeader()) {
      ok = false;
      break;
    }

    const unsigned int remaining = static_cast<unsigned int>(parser.remaining());
    const RTPS::SubmessageHeader smhdr = parser.submessageHeader();

    CORBA::ULong dataExtra = 0;

    switch (smhdr.submessageId) {
    case RTPS::INFO_DST: {
      GuidPrefix_t_forany guidPrefix(receiver.guidPrefix);
      if (!(parser >> guidPrefix)) {
        ok = false;
        break;
      }
      break;
    }
    case RTPS::DATA:
    case RTPS::DATA_FRAG:
      if (!(parser >> dataExtra)) { // extraFlags|octetsToInlineQos
        ok = false;
        break;
      }
      // fall-through
    case RTPS::HEARTBEAT:
    case RTPS::GAP:
    case RTPS::HEARTBEAT_FRAG: {
      if (!(parser >> receiver.entityId)) { // readerId
        ok = false;
        break;
      }
      if (!(parser >> sender.entityId)) { // writerId
        ok = false;
        break;
      }

      check_stateless_volatile(sender.entityId, stateless_or_volatile);
      DDS::OctetSeq plainSm(toSeq(parser.serializer(), smhdr, dataExtra, receiver.entityId, sender.entityId, remaining));
      if (!encode_writer_submessage(sender, receiver, replacements, crypto, plainSm,
                                    link_->handle_registry()->get_local_datawriter_crypto_handle(sender), submessage_start, smhdr.submessageId)) {
        ok = false;
      }
      break;
    }
    case RTPS::ACKNACK:
    case RTPS::NACK_FRAG: {
      if (!(parser >> sender.entityId)) { // readerId
        ok = false;
        break;
      }
      if (!(parser >> receiver.entityId)) { // writerId
        ok = false;
        break;
      }

      check_stateless_volatile(receiver.entityId, stateless_or_volatile);
      DDS::OctetSeq plainSm(toSeq(parser.serializer(), smhdr, 0, sender.entityId, receiver.entityId, remaining));
      if (!encode_reader_submessage(sender, receiver, replacements, crypto, plainSm,
                                    link_->handle_registry()->get_local_datareader_crypto_handle(sender), submessage_start, smhdr.submessageId)) {
        ok = false;
      }
      break;
    }
    default:
      break;
    }

    if (!ok || !parser.hasNextSubmessage()) {
      break;
    }

    if (!parser.skipToNextSubmessage()) {
      ok = false;
    }
  }

  if (!ok) {
    return 0;
  }

  if (replacements.empty()) {
    return plain->duplicate();
  }

  return replace_chunks(plain, replacements);
}

encode_writer_submessage()

bool OpenDDS::DCPS::RtpsUdpSendStrategy::encode_writer_submessage ( const GUID_t &  sender, const GUID_t &  receiver, OPENDDS_VECTOR(Chunk)&  replacements, DDS::Security::CryptoTransform *  crypto, const DDS::OctetSeq &  plain, DDS::Security::DatawriterCryptoHandle  sender_dwch, const char *  submessage_start, CORBA::Octet  msgId  )

private

Definition at line 545 of file RtpsUdpSendStrategy.cpp.

References DDS::Security::CryptoTransform::encode_datawriter_submessage(), OpenDDS::DCPS::RtpsUdpSendStrategy::Chunk::encoded_, OpenDDS::DCPS::GUID_UNKNOWN, DDS::HANDLE_NIL, OpenDDS::DCPS::RtpsUdpDataLink::handle_registry(), OpenDDS::DCPS::RtpsUdpSendStrategy::Chunk::length_, link_, and OpenDDS::DCPS::RtpsUdpSendStrategy::Chunk::start_.

Referenced by encode_submessages().

{
  using namespace DDS::Security;

  if (sender_dwch == DDS::HANDLE_NIL) {
    return true;
  }

  DatareaderCryptoHandle drch = DDS::HANDLE_NIL;
  DatareaderCryptoHandleSeq readerHandles;
  if (std::memcmp(&GUID_UNKNOWN, &receiver, sizeof receiver)) {
     drch = link_->handle_registry()->get_remote_datareader_crypto_handle(receiver);
    if (drch != DDS::HANDLE_NIL) {
      readerHandles.length(1);
      readerHandles[0] = drch;
    }
  }

  CORBA::Long idx = 0;
  SecurityException ex = {"", 0, 0};
  replacements.resize(replacements.size() + 1);
  Chunk& c = replacements.back();
  if (crypto->encode_datawriter_submessage(c.encoded_, plain, sender_dwch, readerHandles, idx, ex)) {
    if (c.encoded_ != plain) {
      c.start_ = submessage_start;
      c.length_ = plain.length();
    } else {
      replacements.pop_back();
    }
  } else {
    log_encode_error(msgId, sender_dwch, sender, drch, receiver, ex);
    replacements.pop_back();
    return false;
  }
  return true;
}

marshal_transport_header()

bool OpenDDS::DCPS::RtpsUdpSendStrategy::marshal_transport_header ( ACE_Message_Block *  mb )

privatevirtual

Reimplemented from OpenDDS::DCPS::TransportSendStrategy.

Definition at line 143 of file RtpsUdpSendStrategy.cpp.

References ACE_Message_Block::cont(), head_, OpenDDS::DCPS::TransportSendStrategy::lock_, rtps_header_data_, OpenDDS::RTPS::RTPSHDR_SZ, and OpenDDS::DCPS::Serializer::write_octet_array().

{
  Serializer writer(mb, encoding_unaligned_native); // byte order doesn't matter for the RTPS Header
  return writer.write_octet_array(reinterpret_cast<ACE_CDR::Octet*>(rtps_header_data_),
    RTPS::RTPSHDR_SZ);
}

max_message_size()

size_t OpenDDS::DCPS::RtpsUdpSendStrategy::max_message_size ( void  ) const

protectedvirtual

The maximum size of a message allowed by the this TransportImpl, or 0 if there is no such limit. This is expected to be a constant, for example UDP/IPv4 can send messages of up to 65466 bytes. The transport framework will use the returned value (if > 0) to fragment larger messages. This fragmentation and reassembly will be transparent to the user.

Reimplemented from OpenDDS::DCPS::TransportSendStrategy.

Definition at line 799 of file RtpsUdpSendStrategy.cpp.

References max_message_size_, MaxSecureFullMessageAdditionalSize, MaxSecureSubmessageAdditionalSize, and OPENDDS_END_VERSIONED_NAMESPACE_DECL.

{
  // TODO: Make this conditional on if the message actually needs to do this.
  return max_message_size_
#ifdef OPENDDS_SECURITY
    // Worst case scenario is full message encryption plus one submessage encryption.
    - MaxSecureSubmessageAdditionalSize - MaxSecureFullMessageAdditionalSize
#endif
    ;
}

override_destinations() [1/2]

RtpsUdpSendStrategy::OverrideToken OpenDDS::DCPS::RtpsUdpSendStrategy::override_destinations

(

const NetworkAddress &

destination

)

Definition at line 123 of file RtpsUdpSendStrategy.cpp.

References override_single_dest_, and OverrideToken.

{
  override_single_dest_ = &destination;
  return OverrideToken(this);
}

override_destinations() [2/2]

RtpsUdpSendStrategy::OverrideToken OpenDDS::DCPS::RtpsUdpSendStrategy::override_destinations

(

const AddrSet &

destinations

)

Definition at line 130 of file RtpsUdpSendStrategy.cpp.

References override_dest_, and OverrideToken.

{
  override_dest_ = &dest;
  return OverrideToken(this);
}

pre_send_packet()

ACE_Message_Block * OpenDDS::DCPS::RtpsUdpSendStrategy::pre_send_packet ( const ACE_Message_Block *  m )

privatevirtual

Derived classes can override to transform the data right before it's sent. If the returned value is non-NULL it will be sent instead of sending the parameter. If the returned value is NULL the original message will be dropped.

Reimplemented from OpenDDS::DCPS::TransportSendStrategy.

Definition at line 452 of file RtpsUdpSendStrategy.cpp.

References ACE_Message_Block::duplicate(), encode_rtps_message(), encode_submessages(), OpenDDS::DCPS::unique_ptr< T, Deleter >::get(), DDS::HANDLE_NIL, link_, OpenDDS::DCPS::RtpsUdpDataLink::local_crypto_handle(), OpenDDS::DCPS::unique_ptr< T, Deleter >::release(), and OpenDDS::DCPS::RtpsUdpDataLink::security_config().

Referenced by send_rtps_control().

{
  const DDS::Security::CryptoTransform_var crypto = link_->security_config()->get_crypto_transform();
  if (!crypto) {
    return plain->duplicate();
  }

  bool stateless_or_volatile = false;
  Message_Block_Ptr submessages(encode_submessages(plain, crypto, stateless_or_volatile));

  if (!submessages || stateless_or_volatile || link_->local_crypto_handle() == DDS::HANDLE_NIL) {
    return submessages.release();
  }

  return encode_rtps_message(submessages.get(), crypto);
}

replace_chunks()

ACE_Message_Block * OpenDDS::DCPS::RtpsUdpSendStrategy::replace_chunks ( const ACE_Message_Block *  plain, const OPENDDS_VECTOR(Chunk)&  replacements  )

private

Definition at line 749 of file RtpsUdpSendStrategy.cpp.

References ACE_Message_Block::copy(), ACE_Message_Block::duplicate(), OpenDDS::DCPS::RtpsUdpSendStrategy::Chunk::encoded_, OpenDDS::DCPS::RtpsUdpSendStrategy::Chunk::length_, OpenDDS::DCPS::unique_ptr< T, Deleter >::release(), OpenDDS::DCPS::RtpsUdpSendStrategy::Chunk::start_, and ACE_Message_Block::total_length().

Referenced by encode_submessages().

{
  unsigned int out_size = static_cast<unsigned int>(plain->total_length());
  for (size_t i = 0; i < replacements.size(); ++i) {
    out_size += replacements[i].encoded_.length();
    out_size -= replacements[i].length_;
  }

  Message_Block_Ptr in(plain->duplicate());
  ACE_Message_Block* cur = in.get();
  Message_Block_Ptr out(new ACE_Message_Block(out_size));
  for (size_t i = 0; i < replacements.size(); ++i) {
    const Chunk& c = replacements[i];
    for (; cur && (c.start_ < cur->rd_ptr() || c.start_ >= cur->wr_ptr());
         cur = cur->cont()) {
      out->copy(cur->rd_ptr(), cur->length());
    }
    if (!cur) {
      return 0;
    }

    const size_t prefix = c.start_ - cur->rd_ptr();
    out->copy(cur->rd_ptr(), prefix);
    cur->rd_ptr(prefix);

    out->copy(reinterpret_cast<const char*>(c.encoded_.get_buffer()), c.encoded_.length());
    for (size_t n = c.length_; n; cur = cur->cont()) {
      if (cur->length() > n) {
        cur->rd_ptr(n);
        break;
      } else {
        n -= cur->length();
      }
    }
  }

  for (; cur; cur = cur->cont()) {
    out->copy(cur->rd_ptr(), cur->length());
  }

  return out.release();
}

security_config()

Security::SecurityConfig_rch OpenDDS::DCPS::RtpsUdpSendStrategy::security_config ( ) const

virtual

Reimplemented from OpenDDS::DCPS::TransportSendStrategy.

Definition at line 379 of file RtpsUdpSendStrategy.cpp.

References link_, and OpenDDS::DCPS::RtpsUdpDataLink::security_config().

Referenced by send_rtps_control().

{
  return link_->security_config();
}

send_bytes_i()

ssize_t OpenDDS::DCPS::RtpsUdpSendStrategy::send_bytes_i ( const iovec  iov[], int  n  )

protectedvirtual

Implements OpenDDS::DCPS::TransportSendStrategy.

Definition at line 67 of file RtpsUdpSendStrategy.cpp.

References send_bytes_i_helper().

{
  ssize_t result = send_bytes_i_helper(iov, n);

  if (result == -1 && shouldWarn(errno)) {
    // Make the framework think this was a successful send to avoid
    // putting the send strategy in suspended mode. If reliability
    // is enabled, the data may be resent later.
    ssize_t b = 0;
    for (int i = 0; i < n; ++i) {
      b += iov[i].iov_len;
    }
    result = b;
  }

  return result;
}

send_bytes_i_helper()

ssize_t OpenDDS::DCPS::RtpsUdpSendStrategy::send_bytes_i_helper ( const iovec  iov[], int  n  )

protected

Definition at line 86 of file RtpsUdpSendStrategy.cpp.

References OpenDDS::DCPS::TransportSendStrategy::current_packet_first_element(), ENOTCONN, OpenDDS::DCPS::RtpsUdpDataLink::get_addresses(), OpenDDS::DCPS::GUID_UNKNOWN, link_, override_dest_, override_single_dest_, OpenDDS::DCPS::TransportQueueElement::publication_id(), send_multi_i(), send_single_i(), and OpenDDS::DCPS::TransportQueueElement::subscription_id().

Referenced by send_bytes_i().

{
  if (override_single_dest_) {
    return send_single_i(iov, n, *override_single_dest_);
  }

  if (override_dest_) {
    return send_multi_i(iov, n, *override_dest_);
  }

  // determine destination address(es) from TransportQueueElement in progress
  TransportQueueElement* elem = current_packet_first_element();
  if (!elem) {
    errno = ENOTCONN;
    return -1;
  }

  AddrSet addrs;
  if (elem->subscription_id() != GUID_UNKNOWN) {
    addrs = link_->get_addresses(elem->publication_id(), elem->subscription_id());

  } else {
    addrs = link_->get_addresses(elem->publication_id());
  }

  if (addrs.empty()) {
    ssize_t result = 0;
    for (int i = 0; i < n; ++i) {
      result += iov[i].iov_len;
    }
    return result;
  }

  return send_multi_i(iov, n, addrs);
}

send_multi_i()

ssize_t OpenDDS::DCPS::RtpsUdpSendStrategy::send_multi_i ( const iovec  iov[], int  n, const AddrSet &  addrs  )

private

Definition at line 250 of file RtpsUdpSendStrategy.cpp.

References send_single_i().

Referenced by send_bytes_i_helper(), and send_rtps_control().

{
  ssize_t result = -1;
  typedef AddrSet::const_iterator iter_t;
  for (iter_t iter = addrs.begin(); iter != addrs.end(); ++iter) {
    if (!*iter) {
      continue;
    }
    const ssize_t result_per_dest = send_single_i(iov, n, *iter);
    if (result_per_dest >= 0) {
      result = result_per_dest;
    }
  }
  return result;
}

send_rtps_control() [1/2]

void OpenDDS::DCPS::RtpsUdpSendStrategy::send_rtps_control	(	RTPS::Message &	message,
		ACE_Message_Block &	submessages,
		const NetworkAddress &	destination
	)

Definition at line 161 of file RtpsUdpSendStrategy.cpp.

References ACE_ERROR, ACE_GUARD, OpenDDS::RTPS::Message::hdr, link_, LM_DEBUG, LM_ERROR, LM_WARNING, OpenDDS::DCPS::MAX_SEND_BLOCKS, OpenDDS::DCPS::TransportSendStrategy::mb_to_iov(), network_is_unreachable_, pre_send_packet(), OpenDDS::DCPS::unique_ptr< T, Deleter >::reset(), rtps_header_mb_, rtps_header_mb_lock_, rtps_message_, rtps_message_mutex_, security_config(), OpenDDS::DCPS::RtpsUdpDataLink::security_config(), send_single_i(), and VDBG.

{
  {
    ACE_GUARD(ACE_Thread_Mutex, g, rtps_message_mutex_);
    message.hdr = rtps_message_.hdr;
  }

  const AMB_Continuation cont(rtps_header_mb_lock_, rtps_header_mb_, submessages);

#ifdef OPENDDS_SECURITY
  Message_Block_Ptr alternate;
  if (security_config()) {
    const DDS::Security::CryptoTransform_var crypto = link_->security_config()->get_crypto_transform();
    if (crypto) {
      alternate.reset(pre_send_packet(&rtps_header_mb_));
      if (!alternate) {
        VDBG((LM_DEBUG, "(%P|%t) RtpsUdpSendStrategy::send_rtps_control () - "
              "pre_send_packet returned NULL, dropping.\n"));
        return;
      }
    }
  }
  ACE_Message_Block& use_mb = alternate ? *alternate : rtps_header_mb_;
#else
  ACE_Message_Block& use_mb = rtps_header_mb_;
#endif

  iovec iov[MAX_SEND_BLOCKS];
  const int num_blocks = mb_to_iov(use_mb, iov);
  const ssize_t result = send_single_i(iov, num_blocks, addr);
  if (result < 0 && !network_is_unreachable_) {
    const ACE_Log_Priority prio = shouldWarn(errno) ? LM_WARNING : LM_ERROR;
    ACE_ERROR((prio, "(%P|%t) RtpsUdpSendStrategy::send_rtps_control() - "
      "failed to send RTPS control message\n"));
  }
}

send_rtps_control() [2/2]

void OpenDDS::DCPS::RtpsUdpSendStrategy::send_rtps_control	(	RTPS::Message &	message,
		ACE_Message_Block &	submessages,
		const AddrSet &	destinations
	)

Definition at line 201 of file RtpsUdpSendStrategy.cpp.

References ACE_ERROR, ACE_GUARD, OpenDDS::RTPS::Message::hdr, link_, LM_DEBUG, LM_ERROR, LM_WARNING, OpenDDS::DCPS::MAX_SEND_BLOCKS, OpenDDS::DCPS::TransportSendStrategy::mb_to_iov(), network_is_unreachable_, pre_send_packet(), OpenDDS::DCPS::unique_ptr< T, Deleter >::reset(), rtps_header_mb_, rtps_header_mb_lock_, rtps_message_, rtps_message_mutex_, security_config(), OpenDDS::DCPS::RtpsUdpDataLink::security_config(), send_multi_i(), and VDBG.

{
  {
    ACE_GUARD(ACE_Thread_Mutex, g, rtps_message_mutex_);
    message.hdr = rtps_message_.hdr;
  }

  const AMB_Continuation cont(rtps_header_mb_lock_, rtps_header_mb_, submessages);

#ifdef OPENDDS_SECURITY
  Message_Block_Ptr alternate;
  if (security_config()) {
    const DDS::Security::CryptoTransform_var crypto = link_->security_config()->get_crypto_transform();
    if (crypto) {
      alternate.reset(pre_send_packet(&rtps_header_mb_));
      if (!alternate) {
        VDBG((LM_DEBUG, "(%P|%t) RtpsUdpSendStrategy::send_rtps_control () - "
              "pre_send_packet returned NULL, dropping.\n"));
        return;
      }
    }
  }
  ACE_Message_Block& use_mb = alternate ? *alternate : rtps_header_mb_;
#else
  ACE_Message_Block& use_mb = rtps_header_mb_;
#endif

  iovec iov[MAX_SEND_BLOCKS];
  const int num_blocks = mb_to_iov(use_mb, iov);
  const ssize_t result = send_multi_i(iov, num_blocks, addrs);
  if (result < 0 && !network_is_unreachable_) {
    const ACE_Log_Priority prio = shouldWarn(errno) ? LM_WARNING : LM_ERROR;
    ACE_ERROR((prio, "(%P|%t) RtpsUdpSendStrategy::send_rtps_control() - "
      "failed to send RTPS control message\n"));
  }
}

send_single_i()

ssize_t OpenDDS::DCPS::RtpsUdpSendStrategy::send_single_i ( const iovec  iov[], int  n, const NetworkAddress &  addr  )

private

Definition at line 280 of file RtpsUdpSendStrategy.cpp.

References ACE_ERROR, ACE_GUARD_RETURN, choose_send_socket(), EMSGSIZE, ENETUNREACH, link_, LM_ERROR, LM_WARNING, OpenDDS::DCPS::MCK_RTPS, network_is_unreachable_, OPENDDS_ASSERT, ACE_SOCK_Dgram::send(), socket(), OpenDDS::DCPS::NetworkAddress::to_addr(), OpenDDS::DCPS::RtpsUdpDataLink::transport(), and OpenDDS::DCPS::TransportSendStrategy::UDP_MAX_MESSAGE_SIZE.

Referenced by send_bytes_i_helper(), send_multi_i(), and send_rtps_control().

{
  OPENDDS_ASSERT(addr);

  const ACE_SOCK_Dgram& socket = choose_send_socket(addr);

  RtpsUdpTransport_rch transport = link_->transport();
  if (!transport) {
    return 0;
  }

  RtpsUdpInst_rch cfg = transport->config();
  if (!cfg) {
    return 0;
  }

#ifdef OPENDDS_TESTING_FEATURES
  ssize_t total_length;
  if (cfg->should_drop(iov, n, total_length)) {
    return total_length;
  }
#endif

#ifdef ACE_LACKS_SENDMSG
  char buffer[UDP_MAX_MESSAGE_SIZE];
  char *iter = buffer;
  for (int i = 0; i < n; ++i) {
    if (size_t(iter - buffer + iov[i].iov_len) > UDP_MAX_MESSAGE_SIZE) {
      ACE_ERROR((LM_ERROR, "(%P|%t) RtpsUdpSendStrategy::send_single_i() - "
                 "message too large at index %d size %d\n", i, iov[i].iov_len));
      return -1;
    }
    std::memcpy(iter, iov[i].iov_base, iov[i].iov_len);
    iter += iov[i].iov_len;
  }
  const ssize_t result = socket.send(buffer, iter - buffer, addr.to_addr());
#else
  const ssize_t result = socket.send(iov, n, addr.to_addr());
#endif
  if (result < 0) {
    if (cfg->count_messages()) {
      const InternalMessageCountKey key(addr, MCK_RTPS, addr == NetworkAddress(cfg->rtps_relay_address()));
      ACE_GUARD_RETURN(ACE_Thread_Mutex, g, transport->transport_statistics_mutex_, -1);
      transport->transport_statistics_.message_count[key].send_fail(result);
    }
    const int err = errno;
    if (err != ENETUNREACH || !network_is_unreachable_) {
      errno = err;
      const ACE_Log_Priority prio = shouldWarn(errno) ? LM_WARNING : LM_ERROR;
      ACE_ERROR((prio, "(%P|%t) RtpsUdpSendStrategy::send_single_i() - "
                 "destination %C failed send: %m\n", DCPS::LogAddr(addr).c_str()));
      if (errno == EMSGSIZE) {
        for (int i = 0; i < n; ++i) {
          ACE_ERROR((prio, "(%P|%t) RtpsUdpSendStrategy::send_single_i: "
              "iovec[%d].iov_len = %B\n", i, size_t(iov[i].iov_len)));
        }
      }
    }
    if (err == ENETUNREACH) {
      network_is_unreachable_ = true;
    }
    // Reset errno since the rest of framework expects it.
    errno = err;
  } else {
    if (cfg->count_messages()) {
      const InternalMessageCountKey key(addr, MCK_RTPS, addr == NetworkAddress(cfg->rtps_relay_address()));
      ACE_GUARD_RETURN(ACE_Thread_Mutex, g, transport->transport_statistics_mutex_, -1);
      transport->transport_statistics_.message_count[key].send(result);
    }
    network_is_unreachable_ = false;
  }
  return result;
}

stop_i()

void OpenDDS::DCPS::RtpsUdpSendStrategy::stop_i ( )

virtual

Let the subclass stop.

Implements OpenDDS::DCPS::TransportSendStrategy.

Definition at line 795 of file RtpsUdpSendStrategy.cpp.

{
}

Friends And Related Function Documentation

OverrideToken

friend struct OverrideToken

friend

Definition at line 43 of file RtpsUdpSendStrategy.h.

Referenced by override_destinations().

Member Data Documentation

link_

RtpsUdpDataLink* OpenDDS::DCPS::RtpsUdpSendStrategy::link_

private

Definition at line 135 of file RtpsUdpSendStrategy.h.

Referenced by add_delayed_notification(), choose_send_socket(), encode_payload(), encode_reader_submessage(), encode_rtps_message(), encode_submessages(), encode_writer_submessage(), pre_send_packet(), security_config(), send_bytes_i_helper(), send_rtps_control(), and send_single_i().

max_message_size_

const size_t OpenDDS::DCPS::RtpsUdpSendStrategy::max_message_size_

private

Definition at line 139 of file RtpsUdpSendStrategy.h.

Referenced by max_message_size().

MaxCryptoFooterSize

const size_t OpenDDS::DCPS::RtpsUdpSendStrategy::MaxCryptoFooterSize = 20

static

Definition at line 64 of file RtpsUdpSendStrategy.h.

MaxCryptoHeaderSize

const size_t OpenDDS::DCPS::RtpsUdpSendStrategy::MaxCryptoHeaderSize = 20

static

Definition at line 63 of file RtpsUdpSendStrategy.h.

MaxSecureFullMessageAdditionalSize

const size_t OpenDDS::DCPS::RtpsUdpSendStrategy::MaxSecureFullMessageAdditionalSize

static

Initial value:

=
    MaxSecureFullMessageLeadingSize + MaxSubmessagePadding + MaxSecureFullMessageFollowingSize

Definition at line 76 of file RtpsUdpSendStrategy.h.

Referenced by max_message_size().

MaxSecureFullMessageFollowingSize

const size_t OpenDDS::DCPS::RtpsUdpSendStrategy::MaxSecureFullMessageFollowingSize = MaxSecureSuffixSize

static

Definition at line 75 of file RtpsUdpSendStrategy.h.

MaxSecureFullMessageLeadingSize

const size_t OpenDDS::DCPS::RtpsUdpSendStrategy::MaxSecureFullMessageLeadingSize

static

Initial value:

=
    RTPS::SMHDR_SZ + RTPS::INFO_SRC_SZ + MaxSecurePrefixSize

Definition at line 73 of file RtpsUdpSendStrategy.h.

MaxSecurePrefixSize

const size_t OpenDDS::DCPS::RtpsUdpSendStrategy::MaxSecurePrefixSize = RTPS::SMHDR_SZ + MaxCryptoHeaderSize

static

Definition at line 65 of file RtpsUdpSendStrategy.h.

MaxSecureSubmessageAdditionalSize

const size_t OpenDDS::DCPS::RtpsUdpSendStrategy::MaxSecureSubmessageAdditionalSize

static

Initial value:

=
    MaxSecureSubmessageLeadingSize + MaxSubmessagePadding + MaxSecureSubmessageFollowingSize

Definition at line 71 of file RtpsUdpSendStrategy.h.

Referenced by max_message_size().

MaxSecureSubmessageFollowingSize

const size_t OpenDDS::DCPS::RtpsUdpSendStrategy::MaxSecureSubmessageFollowingSize

static

Initial value:

=
    RTPS::SMHDR_SZ  + MaxSecureSuffixSize

Definition at line 69 of file RtpsUdpSendStrategy.h.

MaxSecureSubmessageLeadingSize

const size_t OpenDDS::DCPS::RtpsUdpSendStrategy::MaxSecureSubmessageLeadingSize = MaxSecurePrefixSize

static

Definition at line 68 of file RtpsUdpSendStrategy.h.

MaxSecureSuffixSize

const size_t OpenDDS::DCPS::RtpsUdpSendStrategy::MaxSecureSuffixSize = RTPS::SMHDR_SZ + MaxCryptoFooterSize

static

Definition at line 67 of file RtpsUdpSendStrategy.h.

MaxSubmessagePadding

const size_t OpenDDS::DCPS::RtpsUdpSendStrategy::MaxSubmessagePadding = RTPS::SM_ALIGN - 1

static

Definition at line 66 of file RtpsUdpSendStrategy.h.

network_is_unreachable_

AtomicBool OpenDDS::DCPS::RtpsUdpSendStrategy::network_is_unreachable_

private

Definition at line 146 of file RtpsUdpSendStrategy.h.

Referenced by send_rtps_control(), and send_single_i().

override_dest_

const AddrSet* OpenDDS::DCPS::RtpsUdpSendStrategy::override_dest_

private

Definition at line 136 of file RtpsUdpSendStrategy.h.

Referenced by override_destinations(), and send_bytes_i_helper().

override_single_dest_

const NetworkAddress* OpenDDS::DCPS::RtpsUdpSendStrategy::override_single_dest_

private

Definition at line 137 of file RtpsUdpSendStrategy.h.

Referenced by override_destinations(), and send_bytes_i_helper().

rtps_header_data_

char OpenDDS::DCPS::RtpsUdpSendStrategy::rtps_header_data_[RTPS::RTPSHDR_SZ]

private

Definition at line 142 of file RtpsUdpSendStrategy.h.

Referenced by marshal_transport_header().

rtps_header_db_

ACE_Data_Block OpenDDS::DCPS::RtpsUdpSendStrategy::rtps_header_db_

private

Definition at line 143 of file RtpsUdpSendStrategy.h.

rtps_header_mb_

ACE_Message_Block OpenDDS::DCPS::RtpsUdpSendStrategy::rtps_header_mb_

private

Definition at line 144 of file RtpsUdpSendStrategy.h.

Referenced by RtpsUdpSendStrategy(), and send_rtps_control().

rtps_header_mb_lock_

ACE_Thread_Mutex OpenDDS::DCPS::RtpsUdpSendStrategy::rtps_header_mb_lock_

private

Definition at line 145 of file RtpsUdpSendStrategy.h.

Referenced by send_rtps_control().

rtps_message_

RTPS::Message OpenDDS::DCPS::RtpsUdpSendStrategy::rtps_message_

private

Definition at line 140 of file RtpsUdpSendStrategy.h.

Referenced by append_submessages(), RtpsUdpSendStrategy(), and send_rtps_control().

rtps_message_mutex_

ACE_Thread_Mutex OpenDDS::DCPS::RtpsUdpSendStrategy::rtps_message_mutex_

private

Definition at line 141 of file RtpsUdpSendStrategy.h.

Referenced by append_submessages(), and send_rtps_control().

---

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

• RtpsUdpSendStrategy.h
• RtpsUdpSendStrategy.cpp