transport_common_user.h

/*
 * (c) Copyright, Real-Time Innovations, 2005-2024.
 * All rights reserved.
 *
 * No duplications, whole or partial, manual or electronic, may be made
 * without express written permission.  Any such copies, or
 * revisions thereof, must display this notice unaltered.
 * This code contains trade secrets of Real-Time Innovations, Inc.
 */
 
#ifndef transport_common_user_h
#define transport_common_user_h
 
#include "osapi/osapi_type.h"
#include "osapi/osapi_socket.h"
#include "reda/reda_buffer.h"
#include "transport/transport_dll.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ================================================================= */
/*                     Fundamental types                             */
/* ================================================================= */
/*i
 * \file
 * \ingroup NDDS_TransportCommonComponent
 * \brief Basic types and macros used by the \ndds Transport Plugin interface.
 */
 
/*e \dref_TransportConfigurationGroupDocs
 */
 
/* ================================================================= */
/*                  Transport Allocation Settings                    */
/* ================================================================= */
/*e \ingroup NDDS_TransportConfigurationComponent
 *
 * \brief Allocation settings used by various internal buffers.
 *
 * An allocation setting structure defines the rules of memory management
 * used by internal buffers.
 *
 * An internal buffer can provide blocks of memory of fixed size. They
 * are used in several places of any transport, and this structure
 * defines its starting size, limits, and how to increase its capacity.
 *
 * It contains three values:
 * <ul><li>initial_count: the number of individual elements that are
 *         allocated when the buffer is created.
 *
 *     <li>max_count: the maximum number of elements the buffer can
 *         hold. The buffer will grow up to this amount. After this
 *         limit is reached, new allocation requests will fail.
 *         For unlimited size, use the value
 *         NDDS_TRANSPORT_ALLOCATION_SETTINGS_MAX_COUNT_UNLIMITED
 *
 *     <li>incremental_count: The amount of elements that are allocated
 *         at every increment.
 *         You can use the value:
 *         NDDS_TRANSPORT_ALLOCATION_SETTINGS_INCREMENTAL_COUNT_AUTOMATIC
 *         to have the buffer double its size at every reallocation request.
 * </ul>
 */
struct TransportAllocationSettings_t {
    RTI_INT32 initial_count;
    RTI_INT32 max_count;
    RTI_INT32 incremental_count;
};
 
/*e \ingroup NDDS_TransportConfigurationComponent
 *
 * \brief The constant used as 'unlimited' for the 'max_count' field of the
 *        structure \ref TransportAllocationSettings_t
 */
#define NDDS_TRANSPORT_ALLOCATION_SETTINGS_MAX_COUNT_UNLIMITED          (-1)
 
/*e \ingroup NDDS_TransportConfigurationComponent
 *
 * \brief The constant used as 'automatic' for the 'incremental_count' field of
 * the structure \ref TransportAllocationSettings_t
 *
 * Automatic means the buffer size will double at every reallocation.
 */
#define NDDS_TRANSPORT_ALLOCATION_SETTINGS_INCREMENTAL_COUNT_AUTOMATIC  (-1)
 
/*e \ingroup NDDS_TransportConfigurationComponent
 *
 * \brief The constant used as default value for the struct \ref
 * TransportAllocationSettings_t
 *
 * The default value defined in this constant, sets the buffer to have:
 * <ul><li>initial_count = 2 elements
 *     <li>max_count = \ref
 * NDDS_TRANSPORT_ALLOCATION_SETTINGS_MAX_COUNT_UNLIMITED <li>incremental_count
 * = NDDS_TRANSPORT_ALLOCATION_SETTINGS_INCREMENTAL_COUNT_AUTOMATIC
 * </ul>
 */
#define NDDS_TRANSPORT_ALLOCATION_SETTINGS_DEFAULT {                                \
        2L, /* initial_count */                                                     \
        NDDS_TRANSPORT_ALLOCATION_SETTINGS_MAX_COUNT_UNLIMITED, /* max_count */     \
        NDDS_TRANSPORT_ALLOCATION_SETTINGS_INCREMENTAL_COUNT_AUTOMATIC /* incremental_count */ \
}
 
/* ================================================================= */
/*                  Transport Class ID type                          */
/* ================================================================= */
 
/*e
 * \ingroup NDDS_TransportConfigurationComponent
 * \brief Type for storing \ndds Transport Plugin class IDs.
 *
 * Each implementation of a Transport Plugin must have a unique ID.  For
 * example, a UDP/IP Transport Plugin implementation must have a different
 * ID than a Shared Memory Transport Plugin.
 *
 * User-implemented Transport Plugins must have an ID higher than \ref
 * NDDS_TRANSPORT_CLASSID_RESERVED_RANGE.
 */
typedef RTI_INT32 NDDS_Transport_ClassId_t;
 
#define NDDS_TRANSPORT_CLASS_ID_LIST_SIZE 8
 
/*i
 * \ingroup NDDS_TransportConfigurationComponent
 * @brief Array of NDDS_Transport_ClassId_t elements
 *
 * Used in Network Capture as a list of transports to capture frames from.
 * This will be populated by
 * RTINetioConfigurator_getTransportClassIdListFromString
 * with the list of transports (given by the user)
 * and then checked against the transport of the current frame in
 * RTINetioCapManager_enqueueRtpsFrame
 */
struct NDDS_Transport_ClassId_List {
    size_t size;
    NDDS_Transport_ClassId_t elements[NDDS_TRANSPORT_CLASS_ID_LIST_SIZE];
};
 
/*e
 * \ingroup NDDS_TransportConfigurationComponent
 * \brief Invalid Transport Class ID
 *
 * Transport-Plugins implementations should set their class ID to a value
 * different than this.
 */
#define NDDS_TRANSPORT_CLASSID_INVALID (-1)
 
 
#define NDDS_Transport_ClassId_List_INITIALIZER \
{ \
    0, /* size */ \
    { \
        NDDS_TRANSPORT_CLASSID_INVALID, \
        NDDS_TRANSPORT_CLASSID_INVALID, \
        NDDS_TRANSPORT_CLASSID_INVALID, \
        NDDS_TRANSPORT_CLASSID_INVALID, \
        NDDS_TRANSPORT_CLASSID_INVALID, \
        NDDS_TRANSPORT_CLASSID_INVALID, \
        NDDS_TRANSPORT_CLASSID_INVALID, \
        NDDS_TRANSPORT_CLASSID_INVALID \
    } \
}
 
/*i \ingroup NDDS_TransportConfigurationComponent
 * \brief Special \b wildcard transport class. Matches any transport class. A
 * locator with this transport class is applicable to ALL Transport Plugin
 * instances.
 *
 * Physical Transport-Plugins should return a value different than this.
 *
 * Used by \ndds internally, not useful for Transport Plugin implementors.
 */
#define NDDS_TRANSPORT_CLASSID_ANY (0)
 
/*e
 * \ingroup NDDS_TransportConfigurationComponent
 * \brief Builtin IPv4 UDP/IP Transport Plugin class ID.
 */
#define NDDS_TRANSPORT_CLASSID_UDPv4 (1)
 
/*e
 * \ingroup NDDS_TransportConfigurationComponent
 * \brief Builtin Shared-Memory Transport Plugin class ID.
 */
#define NDDS_TRANSPORT_CLASSID_SHMEM (0x01000000)
 
/*e
 * \ingroup NDDS_TransportConfigurationComponent
 * \brief Builtin Shared-Memory Transport Plugin class ID for Connext 5.1.0 and
 * earlier.
 */
#define NDDS_TRANSPORT_CLASSID_SHMEM_510 (2)
 
/*i
 * \ingroup NDDS_TransportConfigurationComponent
 * \brief Builtin Intra-Process Transport Plugin class ID.
 */
#define NDDS_TRANSPORT_CLASSID_INTRA (3)
 
/* NOTE: classid 4 was previously used for starfabric */
 
/*e
 * \ingroup NDDS_TransportConfigurationComponent
 * \brief Builtin IPv6 UDP/IP Transport Plugin class ID.
 */
#define NDDS_TRANSPORT_CLASSID_UDPv6 (2)
 
/*e
 * \ingroup NDDS_TransportConfigurationComponent
 * \brief Builtin IPv6 UDP/IP Transport Plugin class ID for Connext 5.1.0 and
 * earlier.
 */
#define NDDS_TRANSPORT_CLASSID_UDPv6_510 (5)
 
/*e
 * \ingroup NDDS_TransportConfigurationComponent
 * \brief   IPv4 TCP/IP Transport Plugin class ID for LAN case
 */
#define NDDS_TRANSPORT_CLASSID_TCPV4_LAN (8)
 
/*e
 * \ingroup NDDS_TransportConfigurationComponent
 * \brief IPv4 TCP/IP Transport Plugin class ID for WAN case
 */
#define NDDS_TRANSPORT_CLASSID_TCPV4_WAN (9)
 
/*e
 * \ingroup NDDS_TransportConfigurationComponent
 * \brief IPv4 TCP/IP Transport Plugin class name for WAN case
 */
#define NDDS_TRANSPORT_CLASSNAME_TCPV4_WAN "tcpv4_wan"
 
/*e
 * \ingroup NDDS_TransportConfigurationComponent
 * \brief IPv4 TCP/IP Transport Plugin class ID for LAN case with TLS enabled
 */
#define NDDS_TRANSPORT_CLASSID_TLSV4_LAN (10)
 
/*e
 * \ingroup NDDS_TransportConfigurationComponent
 * \brief   IPv4 TCP/IP Transport Plugin class ID for WAN case with TLS enabled
 */
#define NDDS_TRANSPORT_CLASSID_TLSV4_WAN (11)
 
/*i
 * \ingroup NDDS_TransportConfigurationComponent
 * \brief PCIE Transport Plugin class ID.
 */
#define NDDS_TRANSPORT_CLASSID_PCIE (12)
 
/*i
 * \ingroup NDDS_TransportConfigurationComponent
 * \brief Internet Transport Plugin class ID.
 */
#define NDDS_TRANSPORT_CLASSID_ITP (13)
 
/*e
 * \ingroup NDDS_TransportConfigurationComponent
 * \brief Builtin IPv4 UDP/IP Asymmetric Transport Plugin class ID.
 */
#define NDDS_TRANSPORT_CLASSID_UDPv4_WAN (0x01000001)
 
/*e
 * \ingroup NDDS_TransportConfigurationComponent
 * \brief Transport Plugin class IDs below this are reserved by RTI.
 *
 * User-defined Transport-Plugins should use a class ID greater than
 * this number.
 */
#define NDDS_TRANSPORT_CLASSID_RESERVED_RANGE (1000)
 
#define NDDS_Transport_ClassId_ignore_participant_index_for_initial_peers( \
        class_id__) \
    (class_id__ == NDDS_TRANSPORT_CLASSID_UDPv4_WAN)
 
/* Class name definitions for pluggable transports */
#define NDDS_TRANSPORT_IP_CLASSNAME_TCPV4_LAN "tcpv4_lan"
#define NDDS_TRANSPORT_IP_CLASSNAME_TCPV4_WAN "tcpv4_wan"
#define NDDS_TRANSPORT_IP_CLASSNAME_TLSV4_LAN "tlsv4_lan"
#define NDDS_TRANSPORT_IP_CLASSNAME_TLSV4_WAN "tlsv4_wan"
 
/* ================================================================= */
/*                  Transport Short Name                             */
/* ================================================================= */
/*i \ingroup NDDSTransportModule
 * \brief Transport short name.  Specifies the short name of the transports.
 */
#define NDDS_TRANSPORT_SHORTNAME_SHMEM "SHMEM"
#define NDDS_TRANSPORT_SHORTNAME_TCPV4 "TCP4"
#define NDDS_TRANSPORT_SHORTNAME_TLS "TLS"
#define NDDS_TRANSPORT_SHORTNAME_WAN "WAN"
#define NDDS_TRANSPORT_SHORTNAME_UDP4 "UDP4"
#define NDDS_TRANSPORT_SHORTNAME_UDP6 "UDP6"
 
/* ================================================================= */
/*                         Address Type                              */
/* ================================================================= */
 
/*e
 * \defgroup NDDS_Transport_Address_t Transport Address
 * \ingroup NDDSTransportModule
 *
 * \brief Transport-independent addressing scheme using IPv6
 * presentation strings and numerically stored in network-ordered format.
 *
 * The APIs of \ndds uses IPv6 address notation for all transports.
 *
 * Transport Plugin implementations that are not IP-based are required to map
 * whatever addressing scheme natively used by the physical transport (if any)
 * to an address in IPv6 notation and vice versa.
 *
 * IPv6 addresses are numerically stored in 16 bytes. An IPv6 address can be
 * presented In string notation in a variety of ways. For example,
 *
 * \code
 * "00AF:0000:0037:FE01:0000:0000:034B:0089"
 * "AF:0:37:FE01:0:0:34B:89"
 * "AF:0:37:FE01::34B:89"
 * \endcode
 *
 * are all valid IPv6 presentation of the same address.
 *
 * IPv4 address in dot notation can be used to specify the last 4 bytes of the
 * address.  For example,
 *
 * \code
 * "0000:0000:0000:0000:0000:0000:192.168.0.1"
 * "0:0:0:0:0:0:192.168.0.1"
 * "::192.168.0.1"
 * \endcode
 *
 * are all valid IPv6 presentation of the same address.
 *
 * For a complete description of valid IPv6 address notation, consult the IPv6
 * Addressing Architecture (RFC 2373).
 *
 * Addresses are divided into unicast addresses and multicast addresses.
 *
 * Multicast addresses are defined as
 *
 * \li Addresses that start with 0xFF.
 * That is \c FFxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx.
 *
 * or an IPv4 multicast address
 *
 * \li Address in the range \c [::224.0.0.0, ::239.255.255.255]
 *
 * Multicast addresses do not refer to any specific destination (network
 * interface). Instead, they usually refer to a group of network interfaces,
 * often called a "multicast group".
 *
 * Unicast addresses always refer to a specific network interface.
 *
 */
 
#define NDDS_TRANSPORT_ADDRESS_LENGTH (16)
#define NDDS_TRANSPORT_ADDRESS_BIT_LENGTH (128)
 
/*e
 * \ingroup NDDS_Transport_Address_t
 * \brief Addresses are stored individually as network-ordered bytes.
 *
 * \ndds addresses are numerically stored in a transport independent manner.
 * \ndds uses a IPv6-compatible format, which means that the data structure to
 * hold an NDDS_Transport_Address_t is the same size as a data structure needed
 * to hold an IPv6 address.
 *
 * In addition, the functions provided to translate a string representation of
 * an \ndds address to a value assumes that the string presentation follows the
 * IPv6 address presentation as specified in RFC 2373.
 *
 * An NDDS_Transport_Address_t always stores the address in network-byte order
 * (which is Big Endian).
 *
 * For example, IPv4 multicast address of 225.0.0.0 is represented by
 *
 * {{0,0,0,0, 0,0,0,0, 0,0,0,0, 0xE1,0,0,0}} regardless of endianness,
 *
 * where 0xE1 is the 13th byte of the structure (\c network_ordered_value[12]).
 *
 */
typedef struct {
    /*e
     * network-byte ordered (i.e., bit 0 is the most significant bit and bit 128
     * is the least significant bit).
     */
    unsigned char network_ordered_value[NDDS_TRANSPORT_ADDRESS_LENGTH];
} NDDS_Transport_Address_t;
 
/*i
 * @brief Converts an IPv4 address to string.
 *
 * @return
 * RTI_TRUE upon success; RTI_FALSE upon failure (not enough space in the
 * provided buffer)
 */
extern NDDS_Transport_DllExport RTIBool NDDS_Transport_v4Address_to_string(
        const NDDS_Transport_Address_t *me,
        char *buffer,
        size_t buffer_size_in);
 
/*e
 * \ingroup NDDS_Transport_Address_t
 * \brief Converts a numerical address to a printable string representation.
 *
 * @pre The \c buffer_inout provided must be at least \ref
 * NDDS_TRANSPORT_ADDRESS_STRING_BUFFER_SIZE characters long.
 *
 * @param self \st_in The address to be converted.
 *
 * @param buffer_inout \st_inout Storage passed in which to return the string
 * corresponding to the address.
 *
 * @param buffer_size_in \st_in The size of the storage buffer. Must be
 * >= \ref NDDS_TRANSPORT_ADDRESS_STRING_BUFFER_SIZE
 *
 * @return 1 upon success; 0 upon failure (not enough space in the provided
 * buffer)
 */
extern NDDS_Transport_DllExport RTIBool NDDS_Transport_Address_to_string(
        const NDDS_Transport_Address_t *self,
        char *buffer_inout,
        size_t buffer_size_in);
 
/*e
 * @brief Converts an address to string given its class ID.
 *
 * @return
 * 1 upon success; 0 upon failure (not enough space in the provided buffer)
 */
extern NDDS_Transport_DllExport RTIBool
NDDS_Transport_Address_to_string_with_class_id(
        const NDDS_Transport_Address_t *me,
        char *buffer,
        size_t buffer_size_in,
        NDDS_Transport_ClassId_t transport_class_id);
 
/*e
 * \ingroup NDDS_Transport_Address_t
 * \brief Converts a numerical address to a printable string representation with
 * IPv4 dotted notation or IPv6 presentation string depending on the provided
 * protocol family.
 *
 * @pre The \c buffer_inout provided must be at least
 * \ref NDDS_TRANSPORT_ADDRESS_STRING_BUFFER_SIZE characters long.
 *
 * @param me \st_in The address to be converted.
 *
 * @param buffer \st_inout Storage passed in which to return the string
 * corresponding to the address.
 *
 * @param buffer_size_in \st_in The size of the storage buffer. Must be
 * >= \ref NDDS_TRANSPORT_ADDRESS_STRING_BUFFER_SIZE
 *
 * @param family \st_in The protocol family RTI_OSAPI_SOCKET_AF_INET or
 * RTI_OSAPI_SOCKET_AF_INET6
 *
 * @return RTI_TRUE upon success; 0 upon failure (not enough space in the
 * provided buffer)
 */
extern NDDS_Transport_DllExport RTIBool
NDDS_Transport_Address_to_string_with_protocol_family_format(
        const NDDS_Transport_Address_t *me,
        char *buffer,
        size_t buffer_size_in,
        RTIOsapiSocketAFKind family);
 
/*e
 * \ingroup NDDS_Transport_Address_t
 * \brief Converts an address (IPv4 dotted notation or IPv6 presentation string)
 * into a numerical address.
 *
 * The address string must be in IPv4 dotted notation (X.X.X.X) or IPv6
 * presentation notation.  The string cannot be a hostname since this
 * function does not perform a hostname lookup.
 *
 * @param address_out \st_out Numerical value of the address.
 *
 * @param address_in  \st_in  String representation of an address.
 *
 * @return 1 if address_out contains a valid address, 0 if it was not able to
 * convert the string into an address.
 */
extern NDDS_Transport_DllExport RTI_INT32 NDDS_Transport_Address_from_string(
        NDDS_Transport_Address_t *address_out,
        const char *address_in);
 
/*e
 * \ingroup NDDS_Transport_Address_t
 * \brief Prints an address to standard out.
 *
 * @param address_in \st_in Address to be printed.
 * @param desc_in    \st_in A prefix to be printed before the address.
 * @param indent_in  \st_in Indentation level for the printout.
 */
extern NDDS_Transport_DllExport void NDDS_Transport_Address_print(
        const NDDS_Transport_Address_t *address_in,
        const char *desc_in,
        RTI_INT32 indent_in);
 
/*i
 * \ingroup NDDS_Transport_Address_t
 * \brief Copies an address.
 *
 *  @param dst_out \st_out To where the address is copied.
 *  @param src_in  \st_in  From where the address is copied.
 */
extern NDDS_Transport_DllExport void NDDS_Transport_Address_copy(
        NDDS_Transport_Address_t *dst_out,
        const NDDS_Transport_Address_t *src_in);
 
/*i
 * \ingroup NDDS_Transport_Address_t
 * \brief Compares two addresses for equality.
 *
 * Does the comparison (l_in == r_in) ?
 *
 * @param l_in \st_in Address left.
 * @param r_in \st_in Address right.
 *
 * @return 1 if addresses are equal, 0 otherwise.
 */
extern NDDS_Transport_DllExport RTI_INT32 NDDS_Transport_Address_is_equal(
        const NDDS_Transport_Address_t *l_in,
        const NDDS_Transport_Address_t *r_in);
 
/*i
 * \ingroup NDDS_Transport_Address_t
 * \brief Compares two addresses for equality using only significant bits.
 *
 * Does the comparison (l_in == r_in) using only the number of
 * significant bits as indicated by \c transport_address_bit_count_in.
 *
 * @param l_in \st_in Address left.
 * @param r_in \st_in Address right.
 * @param transport_address_bit_count_in \st_in Only pays attention to this
 * many least significant (i.e. right-most) bits in the address. The most
 * significant (i.e. lesftmost) \c 128 - \c address_bit_count_in bits are
 * ignored.
 *
 * @return 1 if the \c address_bit_count_in least significant (i.e. rightmost)
 * bits are equal,0 otherwise.
 */
extern NDDS_Transport_DllExport RTI_INT32 NDDS_Transport_Address_bits_are_equal(
        const NDDS_Transport_Address_t *l_in,
        const NDDS_Transport_Address_t *r_in,
        RTI_INT32 transport_address_bit_count_in);
 
/*i
 * \ingroup NDDS_Transport_Address_t
 * \brief Compares the value of two addresses.
 *
 * This function treats the addresses as 16-byte numerical values, and
 * then compares them.
 *
 * @param l_in \st_in Address left.
 * @param r_in \st_in Address right.
 *
 * @return 1 if l_in > r_in, 0 if l_ in == r_in, -1 if l_in < r
 */
extern NDDS_Transport_DllExport RTI_INT32 NDDS_Transport_Address_compare(
        const NDDS_Transport_Address_t *l_in,
        const NDDS_Transport_Address_t *r_in);
 
/*e
 * \ingroup NDDS_Transport_Address_t
 * \brief Checks if an address is an IPv4 address.
 *
 * @param address_in \st_in Address to be tested.
 *
 * @note May be implemented as a macro for efficiency.
 *
 * @return 1 if address is an IPv4 address, 0 otherwise.
 */
extern NDDS_Transport_DllExport RTI_INT32
NDDS_Transport_Address_is_ipv4(const NDDS_Transport_Address_t *address_in);
 
/*e
 * \ingroup NDDS_Transport_Address_t
 * \brief Checks if an address is an IPv4 or IPv6 multicast address.
 *
 * @param address_in \st_in Address to be tested.
 *
 * May be implemented as a macro for efficiency.
 *
 * @return 1 if address is a multicast address, 0 otherwise.
 */
extern NDDS_Transport_DllExport RTI_INT32
NDDS_Transport_Address_is_multicast(const NDDS_Transport_Address_t *address_in);
 
/*i
 * \ingroup NDDS_Transport_Address_t
 * @brief Fill from host byte order IPv4 address
 */
extern NDDS_Transport_DllExport void NDDS_Transport_Address_from_ipv4_host_byte(
        NDDS_Transport_Address_t *me,
        RTI_UINT32 ipv4AddressInHostOrderIn);
 
/*i
 * \ingroup NDDS_Transport_Address_t
 * @brief convert to host byte order IPv4 address
 */
extern NDDS_Transport_DllExport RTI_UINT32
NDDS_Transport_Address_to_ipv4_host_byte(const NDDS_Transport_Address_t *me);
 
/*e
 * \ingroup NDDS_Transport_Address_t
 * \brief An invalid transport address. Used as an initializer.
 *
 *  For example:
 *  NDDS_Transport_Address_t address =
 *          NDDS_TRANSPORT_ADDRESS_INVALID_INITIALIZER;
 */
#define NDDS_TRANSPORT_ADDRESS_INVALID_INITIALIZER \
  { \
    { \
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 \
    } \
  }
 
/*e
 * \ingroup NDDS_Transport_Address_t
 * \brief An invalid transport address.
 */
extern NDDS_Transport_DllVariable const NDDS_Transport_Address_t
        NDDS_TRANSPORT_ADDRESS_INVALID;
 
/*e
 * \ingroup NDDS_Transport_Address_t
 *  \brief The minimum size of the buffer that should be passed to
 *  \ref NDDS_Transport_Address_to_string.
 *
 *  For regular addresses, the string size needs to be at least 40 to include
 *  space for 8 tuples of 4 characters each plus 7 delimiting colons plus a
 *  terminating NULL.
 *
 * To support UDPv4_WAN strings, it has been adjusted to 72 to fit the following
 * representation (plus NULL terminator):
 * f=XXXXRBPU,u={FF,FF,FF,FF,FF,FF,FF,FF,FF},p=255.255.255.255:65555:65555
 */
#define NDDS_TRANSPORT_ADDRESS_STRING_BUFFER_SIZE (72)
#define NDDS_TRANSPORT_V4_ADDRESS_STRING_BUFFER_SIZE (16)
 
/* Functions that forward information from transport to dds_c */
 
/*
 * Called when preallocating memory for encoded content.
 *
 * Unlike the participant forwarder APIs, the transport ones don't have the
 * worker as an input argument. They get it from the DomainParticipant when
 * they require it. They do so because the concept of worker is not currently
 * part of the pluggable transports APIs.
 */
typedef unsigned int (
        *NDDS_Transport_Plugin_DomainParticipant_Get_Transformed_Outgoing_Message_Size_Function)(
        void *domain_participant_ptr,
        unsigned int message_size);
 
/*
 * Unlike the participant forwarder APIs, the transport ones don't have the
 * worker as an input argument. They get it from the DomainParticipant when
 * they require it. They do so because the concept of worker is not currently
 * part of the pluggable transports APIs.
 */
typedef RTIBool (
        *NDDS_Transport_Plugin_DomainParticipant_Transform_Outgoing_Message_Function)(
        void *domain_participant_ptr,
        /* output */
        struct REDABuffer *transformed_message,
        /* inputs */
        const struct REDABuffer *message_buffers,
        int message_buffer_count);
 
/*
 * Unlike the participant forwarder APIs, the transport ones don't have the
 * worker as an input argument. They get it from the DomainParticipant when
 * they require it. They do so because the concept of worker is not currently
 * part of the pluggable transports APIs.
 */
typedef RTIBool (
        *NDDS_Transport_Plugin_DomainParticipant_Transform_Incoming_Message_Function)(
        void *domain_participant_ptr,
        /* output */
        struct REDABuffer *transformed_message,
        /* input */
        const struct REDABuffer *message_buffer);
 
struct NDDS_Transport_Plugin_DomainParticipantForwarder {
    NDDS_Transport_Plugin_DomainParticipant_Get_Transformed_Outgoing_Message_Size_Function
            getTransformedOutgoingMessageSize;
    NDDS_Transport_Plugin_DomainParticipant_Transform_Outgoing_Message_Function
            transformOutgoingMessage;
    NDDS_Transport_Plugin_DomainParticipant_Transform_Incoming_Message_Function
            transformIncomingMessage;
};
 
#ifdef __cplusplus
} /* extern "C" */
#endif
 
#endif /* transport_common_user_h */