TCP/TLS Transport Properties

Properties for NDDS_Transport_TCPv4_Property_t describes the TCP and TLS transport properties.

Note: To use TLS, you also need RTI TLS Support, which is a separate component.

Properties for NDDS_Transport_TCPv4_Property_t

Property Name

(prefix with ‘dds.transport.TCPv4.tcp1.’)1Assuming you used ‘dds.transport.TCPv4.tcp1’ as the alias to load the plugin. If not, change the prefix to match the string used with dds.transport.load_plugins. This prefix must begin with 'dds.transport.'

Description

dds.transport.load_plugins

(Note: this does not take a prefix)

Required

Comma-separated strings indicating the prefix names of all plugins that will be loaded by Connext DDS. For example: “dds.transport.TCPv4.tcp1". You will use this string as the prefix to the property names.

Note: you can load up to 8 plugins.

library

Only required if linking dynamically

If used, must be "nddstransporttcp".

This library must be in your library search path (pointed to by the environment variable LD_LIBRARY_PATH on UNIX/Solaris systems, Path on Windows systems, LIBPATH on AIX systems, DYLD_LIBRARY_PATH on OS X systems).

create_function

Only required if linking dynamically

If used, must be “NDDS_Transport_TCPv4_create”.

create_function_ptr

Only required if linking statically

Defines the function pointer to the TCP Transport Plugin creation function. Used for loading TCP Transport Plugin statically.

Must be set to the NDDS_Transport_TCPv4_create function pointer.

tls_create_function_ptr

Defines the function pointer to the TLS Support creation function. Used for loading TLS Support libraries statically.

Must be set to the RTITLS_ConnectionEndpointFactoryTLSv4_create function pointer.

Note: In order to have effect, the tls_delete_function_ptr property must also be set.

tls_delete_function_ptr

Defines the function pointer to the TLS Support deletion function. Used for loading TLS Support libraries statically.

Must be set to the RTITLS_ConnectionEndpointFactoryTLSv4_delete function pointer.

Note: In order to have effect, the tls_create_function_ptr property must also be set.

aliases

Used to register the transport plugin returned by NDDS_Transport_TCPv4_create() (as specified by <TCP_prefix>.create_function) to the DomainParticipant. Aliases should be specified as a comma-separated string, with each comma delimiting an alias.

If it is not specified, the prefix—without the leading "dds.transport"—is used as the default alias for the plugin. For example, if the <TRANSPORT_PREFIX> is "dds.transport.mytransport", the default alias for the plugin is "mytransport".

parent.classid

Must be set to one of the following values:

  • NDDS_TRANSPORT_CLASSID_TCPV4_LAN
    for TCP communication within a LAN
  • NDDS_TRANSPORT_CLASSID_TLSV4_LAN
    for TLS communication within a LAN
  • NDDS_TRANSPORT_CLASSID_TCPV4_WAN
    for TCP communication across LANs and firewalls
  • NDDS_TRANSPORT_CLASSID_TLSV4_WAN
    for TLS communication across LAN and firewalls

Default: NDDS_TRANSPORT_CLASSID_TCPV4_LAN

Note: To use either TLS mode, you also need RTI TLS Support which is available for purchase as a separate package.

parent.gather_send_
buffer_count_max

Specifies the maximum number of buffers that Connext DDS can pass to the send() function of the transport plugin.

The transport plugin send() API supports a gather-send concept, where the send() call can take several discontiguous buffers, assemble and send them in a single message. This enables Connext DDS to send a message from parts obtained from different sources without first having to copy the parts into a single contiguous buffer.

However, most transports that support a gather-send concept have an upper limit on the number of buffers that can be gathered and sent. Setting this value will prevent Connext DDS from trying to gather too many buffers into a send call for the transport plugin.

Connext DDS requires all transport-plugin implementations to support a gather-send of least a minimum number of buffers. This minimum number is defined as NDDS_TRANSPORT_PROPERTY_GATHER_SEND_BUFFER_COUNT_MIN.

Default: 128

parent.message_size_max

The maximum size of a message in bytes that can be sent or received by the transport plugin.

Default: 65536

parent.allow_interfaces_list

A list of strings, each identifying a range of interface addresses that can be used by the transport.

Interfaces must be specified as comma-separated strings, with each comma delimiting an interface.

For example: 10.10.*, 10.15.*

If the list is non-empty, this "white" list is applied before parent.deny_interfaces_list.

Default: All available interfaces are used.

parent.deny_interfaces_list

A list of strings, each identifying a range of interface addresses that will not be used by the transport.

If the list is non-empty, deny the use of these interfaces.

Interfaces must be specified as comma-separated strings, with each comma delimiting an interface.

For example: 10.10.*

This "black" list is applied after parent.allow_interfaces_list and filters out the interfaces that should not be used.

Default: No interfaces are denied

send_socket_buffer_size

Size, in bytes, of the send buffer of a socket used for sending. On most operating systems, setsockopt() will be called to set the SENDBUF to the value of this parameter.

This value must be greater than or equal to parent.message_size_max, or -1.

When set to -1, setsockopt() (or equivalent) will not be called to size the send buffer of the socket.

The maximum value is operating system-dependent.

Default: 131072

recv_socket_buffer_size

Size, in bytes, of the receive buffer of a socket used for receiving.

On most operating systems, setsockopt() will be called to set the RECVBUF to the value of this parameter.

This value must be greater than or equal to parent.message_size_max, or -1.

When set to -1, setsockopt() (or equivalent) will not be called to size the receive buffer of the socket.

The maximum value is operating-system dependent.

Default: 131072

ignore_loopback_interface

Prevents the transport plugin from using the IP loopback interface.

This property is ignored when parent.classid is NDDS_TRANSPORT_CLASSID_TCPV4_WAN or NDDS_TRANSPORT_CLASSID_TLSV4_WAN.

Two values are allowed:

  • 0: Enable local traffic via this plugin. The plugin will only use and report the IP loopback interface only if there are no other network interfaces (NICs) up on the system.
  • 1: Disable local traffic via this plugin. This means “do not use the IP loopback interface, even if no NICs are discovered.” This setting is useful when you want applications running on the same node to use a more efficient plugin like shared memory instead of the IP loopback.

Default: 1

DEPRECATED

ignore_nonrunning_interfaces

This property is deprecated.

It prevents the transport plugin from using a network interface that is not reported as RUNNING by the operating system.

The transport checks the flags reported by the operating system for each network interface upon initialization. An interface which is not reported as UP will not be used. This property allows the same check to be extended to the IFF_RUNNING flag implemented by some operating systems. The RUNNING flag is defined to mean that "all resources are allocated" and may be off if no link is detected (e.g., the network cable is unplugged).

Two values are allowed:

  • 0: Do not check the RUNNING flag when enumerating interfaces, just make sure the interface is UP.
  • 1: Check the flag when enumerating interfaces, and ignore those that are not reported as RUNNING. This can be used on some operating systems to cause the transport to ignore interfaces that are enabled but not connected to the network.

Default: 1

transport_priority_mask

Mask for the transport priority field. This is used in conjunction with transport_priority_mapping_low/transport_priority_mapping_high to define the mapping from DDS transport priority to the IPv4 TOS field. Defines a contiguous region of bits in the 32-bit transport priority value that is used to generate values for the IPv4 TOS field on an outgoing socket.

For example, the value 0x0000ff00 causes bits 9-16 (8 bits) to be used in the mapping. The value will be scaled from the mask range (0x0000 -0xff00 in this case) to the range specified by low and high.

If the mask is set to zero, then the transport will not set IPv4 TOS for send sockets.

Default: 0

transport_priority_mapping_low

Sets the low and high values of the output range to IPv4 TOS.

These values are used in conjunction with transport_priority_mask to define the mapping from DDS transport priority to the IPv4 TOS field. Defines the low and high values of the output range for scaling.

Note that IPv4 TOS is generally an 8-bit value.

Default transport_priority_mapping_low: 0

Default transport_priority_mapping_high: 0xFF

transport_priority_mapping_high

interface_poll_period

Specifies the period in milliseconds to query for changes in the state of all the interfaces.

See Setting Builtin Transport Properties with the PropertyQosPolicy in Setting Builtin Transport Properties with the PropertyQosPolicy

server_socket_backlog

The backlog parameter determines what is the maximum length of the queue of pending connections.

Default: 5

public_address

Required for WAN communication (see note below)

Public IP address and port (WAN address and port) (separated with ‘:’ ) associated with the transport instantiation.

For example: 10.10.9.10:4567

This field is used only when parent.classid is NDDS_TRANSPORT_CLASSID_TCPV4_WAN or NDDS_TRANSPORT_CLASSID_TLSV4_WAN.

The public address and port are necessary to support communication over WAN that involves Network Address Translators (NATs). Typically, the address is the public address of the IP router that provides access to the WAN. The port is the IP router port that is used to reach the private server_bind_port inside the LAN from the outside. This value is expressed as a string in the form: ip[:port], where ip represents the IPv4 address and port is the external port number of the router.

Host names are not allowed in the public_address because they may resolve to an internet address that is not what you want (i.e., ‘localhost’ may map to your local IP or to 127.0.0.1).

Note: If you are using an asymmetric configuration, public_address does not have to be set for the non-public peer.

bind_interface_address

The TCP transport can be configured to bind all sockets to a specified interface.

If NULL, the sockets will be bound to the special IP address INADDR_ANY. This address allows the sockets to receive packets destined to any of the interfaces.

This field should be set in multi-homed systems communicating across NAT routers.

server_bind_port

Private IP port (inside the LAN) used by the transport to accept TCP connections.

If this property is set to zero, the transport will disable the internal server socket, making it impossible for external peers to connect to this node. In this case, the node is considered unreachable and will communicate only using the asymmetric mode with other (reachable) peers.

For WAN communication, this port must be forwarded to a public port in the NAT-enabled router that connects to the outer network.

The server_bind_port cannot be shared among multiple participants on a common host. On most operating systems, attempting to reuse the same server_bind_port for multiple participants on a common host will result in a "port already in use" error. However, Windows systems will not recognize if the server_bind_port is already in use; therefore care must be taken to properly configure Windows systems.

Default: 7400

read_buffer_allocation

Allocation settings applied to read buffers.

These settings configure the initial number of buffers, the maximum number of buffers and the buffers to be allocated when more buffers are needed.

Default:

  • read_buffer_allocation.initial_count = 2
  • read_buffer_allocation.max_count = -1 (unlimited)
  • read_buffer_allocation.incremental_count = -1 (number of buffers will keep doubling on each allocation until it reaches max_count)

write_buffer_allocation

Allocation settings applied to buffers used for asynchronous (non-blocking) write.

These settings configure the initial number of buffers, the maximum number of buffers and the buffers to be allocated when more buffers are needed.

Default:

  • write_buffer_allocation.initial_count = 4
  • write_buffer_allocation.max_count = 1000
  • write_buffer_allocation.incremental_count = 10

Note that for the write buffer pool, the max_count is not set to unlimited. This is to avoid having a fast writer quickly exhaust all the available system memory, in case of a temporary network slowdown. When this write buffer pool reaches the maximum, the low-level send command of the transport will fail; at that point Connext DDS will take the appropriate action (retry to send or drop it), according to the application’s QoS (if the transport is used for reliable communication, the data will still be sent eventually).

control_buffer_allocation

Allocation settings applied to buffers used to serialize and send control messages.

These settings configure the initial number of buffers, the maximum number of buffers and the buffers to be allocated when more buffers are needed.

Default:

  • control_buffer_allocation.initial_count = 2
  • control_buffer_allocation.max_count = -1 (unlimited)
  • control_buffer_allocation.incremental_count = -1 (number of buffers will keep doubling on each allocation until it reaches max_count)

control_message_allocation

Allocation settings applied to control messages.

These settings configure the initial number of messages, the maximum number of messages and the messages to be allocated when more messages are needed.

Default:

  • control_message_allocation.initial_count = 2
  • control_message_allocation.max_count = -1 (unlimited)
  • control_message_allocation.incremental_count = -1 (number of messages will keep doubling on each allocation until it reaches max_count)

control_attribute_allocation

Allocation settings applied to control messages attributes.

These settings configure the initial number of attributes, the maximum number of attributes and the attributes to be allocated when more attributes are needed.

Default:

  • control_attribute_allocation.initial_count = 2
  • control_attribute_allocation.max_count = -1 (unlimited)
  • control_attribute_allocation.incremental_count = -1 (number of attributes will keep doubling on each allocation until it reaches max_count)

force_asynchronous_send

Forces asynchronous send. When this parameter is set to 0, the TCP transport will attempt to send data as soon as the internal send() function is called. When it is set to 1, the transport will make a copy of the data to send and enqueue it in an internal send buffer. Data will be sent as soon as the low-level socket buffer has space.

Normally setting it to 1 delivers better throughput in a fast network, but will result in a longer time to recover from various TCP error conditions. Setting it to 0 may cause the low-level send() function to block until the data is physically delivered to the lower socket buffer. For an application writing data at a very fast rate, it may cause the caller thread to block if the send socket buffer is full. This could produce lower throughput in those conditions (the caller thread could prepare the next packet while waiting for the send socket buffer to become available).

Default: 0

max_packet_size

The maximum size of a TCP segment.

This parameter is only supported on Linux architectures.

By default, the maximum size of a TCP segment is based on the network MTU for destinations on a local network, or on a default 576 for destinations on non-local networks. This behavior can be changed by setting this parameter to a value between 1 and 65535.

Default: -1 (default behavior)

enable_keep_alive

Configures the sending of KEEP_ALIVE messages in TCP.

Setting this value to 1, causes a KEEP_ALIVE packet to be sent to the remote peer if a long time passes with no other data sent or received.

This feature is implemented only on architectures that provide a low-level implementation of the TCP keep-alive feature.

On Windows systems, the TCP keep-alive feature can be globally enabled through the system’s registry: \HKEY_LOCAL_MACHINE\SYSTEM\
CurrentControlSet\Tcpip\Parameters
.

Refer to MSDN documentation for more details.

On Solaris systems, most of the TCP keep-alive parameters can be changed though the kernel properties.

Default: 0

keep_alive_time

Specifies the interval of inactivity in seconds that causes TCP to generate a KEEP_ALIVE message.

This parameter is only supported on Linux and Mac architectures.

Default: -1 (OS default value)

keep_alive_interval

Specifies the interval in seconds between KEEP_ALIVE retries.

This parameter is only supported on Linux architectures.

Default: -1 (OS default value)

keep_alive_retry_count

The maximum number of KEEP_ALIVE retries before dropping the connection.

This parameter is only supported on Linux architectures.

Default: -1 (OS default value)

user_timeout

Changes the default OS TCP User Timeout configuration. If set to a value greater than 0, it specifies the maximum amount of time in seconds that transmitted data may remain unacknowledged before TCP will forcibly close the corresponding connection and return ETIMEDOUT to the application.

If set to 0, TCP Transport plugin will use the system default.

Currently this feature is supported only on Linux 2.6.37 and higher platforms.

Default: 0 (use system's default).

connection_liveliness_settings

Configures the connection liveliness feature. See Connection Liveliness.

Defaults:

  • connection_liveliness_settings.enable: 0
  • connection_liveliness_settings.lease_duration: 10
  • connection_liveliness_settings.assertions_per_lease_duration: 3

event_thread_settings

Configures the event thread used by the TCP Transport plugin for providing some features.

Defaults:

  • event_thread_settings.priority: THREAD_PRIORITY_DEFAULT
  • event_thread_settings.stack_size: THREAD_STACK_SIZE_DEFAULT
  • event_thread_settings.mask: PRIORITY_ENFORCE | STDIO

disable_nagle

Disables the TCP nagle algorithm.

When this property is set to 1, TCP segments are always sent as soon as possible, which may result in poor network utilization.

Default: 0

logging_verbosity_bitmap

Bitmap that specifies the verbosity of log messages from the transport.

Logging values:

  • -1 (0xffffffff): do not change the current verbosity
  • 0x00: silence
  • 0x01: errors
  • 0x02: warnings
  • 0x04: local
  • 0x08: remote
  • 0x10: period
  • 0x80: other (used for control protocol tracing)
  • 0x9F: all (errors, warnings, local, remote, period, and other)

You can combine these values by logically ORing them together.

Default: -1

Note: the logging verbosity is a global property shared across multiple instances of the TCP transport. If you create a new TCP Transport instance with logging_verbosity_bitmap different than -1, the change will affect all the other instances as well.

The default TCP transport verbosity is errors and warnings.

Note: The option of 0x80 (other) is used only for tracing the internal control protocol. Since the output is very verbose, this feature is enabled only in the debug version of the TCP Transport library
(libnddstransporttcpd.so / LIBNDDSTRANSPORTD.LIB).

security_logging_verbosity_bitmap

Bitmap that specifies the verbosity of security related log messages from the transport. These are usually messages generated by OpenSSL.

Logging values:

  • -1 (0xffffffff): Inherit logging_verbosity_bitmap value
  • 0x00: silence
  • 0x01: errors
  • 0x02: warnings
  • 0x04: local
  • 0x08: remote
  • 0x10: period

You can combine these values by logically ORing them together.

Default: -1 (Inherit logging_verbosity_bitmap value)

Note: The security logging verbosity is a global property shared across multiple instances of the TCP transport. If you create a new TCP Transport instance with a security_logging_verbosity_bitmap other than -1, the change will affect all the other instances as well.

socket_monitoring_kind

Configures the socket monitoring API used by the transport. This property can have the following values:

  • SELECT: The transport uses the POSIX select API to monitor sockets.
  • WINDOWS_IOCP: The transport uses Windows I/O completion ports to monitor sockets. This value only applies to Windows systems.
  • WINDOWS_WAITFORMULTIPLEOBJECTS: The transport uses the API WaitForMultipleObjects to monitor sockets. This value only applies to Windows systems.

Default: SELECT

Note: The value selected for this property may affect transport performance and scalability. On Windows systems, using WINDOWS_IOCP provides the best performance and scalability.

windows_iocp_settings

Configures I/O completion ports when socket_monitoring_kind is set to WINDOWS_IOCP.

This setting configures the number of threads the plugin creates to process I/O completion packets (thread_pool_size) and the number of those threads that the operating system can allow to concurrently run (concurrency_value).

Defaults:

windows_iocp_settings.thread_pool_size: 2

windows_iocp_settings.concurrency_value: 1

send_crc

When set to 1, enables the computation of the CRC for sent RTI TCP messages.

Default: 0

force_crc_check

When set to 1, forces the checking of the CRC for received RTI TCP messages. By default, the TCP Transport plugin will only validate the CRC if the CRC is present in the received message. If this property is set to 1, TCP Transport will drop messages not including the CRC.

Default: 0

negotiate_session_id

When set to 1, the TCP Transport Plugin will perform a session negotiation that will help external load balancers identify all the connections associated with a particular session between two Connext DDS applications. This keeps the connections from being divided among multiple servers and ensures proper communication.

For more information about this property, see Support for External Hardware Load Balancers in TCP Transport Plugin.

Default: 0

Note: The value of this property must be consistent among all the applications running the TCP Transport Plugin. If two applications have a different value for this property, they may not communicate.

outstanding_connection_cookies

Maximum number of outstanding connection cookies allowed by the transport when acting as server.

A connection cookie is a token provided by a server to a client; it is used to establish a data connection. Until the data connection is established, the cookie cannot be reused by the server.

To avoid wasting memory, it is good practice to set a cap to the maximum number of connection cookies (pending connections).

When the maximum value is reached, a client will not be able to connect to the server until new cookies become available.

Range: 1 or higher, or -1 (which means an unlimited number).

Default: 100

outstanding_connection_
cookies_life_span

Maximum lifespan (in seconds) of the cookies associated with pending connections.

If a client does not connect to the server before the lifespan of its cookie expires, it will have to request a new cookie.

Range: 1 second or higher, or -1

Default: -1, which means an unlimited amount of time (effectively disabling the feature).

send_max_wait_sec

Controls the maximum time (in seconds) the low-level sendto() function is allowed to block the caller thread when the TCP send buffer becomes full.

If the bandwidth used by the transport is limited, and the sender thread tries to push data faster than the OS can handle, the low-level sendto() function will block the caller until there is some room available in the queue. Limiting this delay eliminates the possibility of deadlock and increases the response time of the internal DDS thread.

This property affects both CONTROL and DATA streams. It only affects SYNCHRONOUS send operations. Asynchronous sends never block a send operation.

For synchronous send() calls, this property limits the time the DDS sender thread can block for a full send buffer. If it is set too large, Connext DDS not only won't be able to send more data, it also won't be able to receive any more data because of an internal resource mutex.

Setting this property to 0 causes the low-level function to report an immediate failure if the TCP send buffer is full.

Setting this property to -1 causes the low-level function to block forever until space becomes available in the TCP buffer.

Default: 3 seconds.

client_connection_negotiation_timeout

Timeout (in seconds) for negotiating a client data connection.

The TCP Transport plugin requires some negotiation before establishing a connection. This property controls the maximum time (in seconds) a client data connection negotiation can remain in progress.

In particular, it controls a maximum timeout for requesting and replying to a server logical port request.

If the negotiation of a connection has not completed after the specified timeout, the negotiation will restart, and if there is an associated data connection, it will be closed. This way, the TCP Transport plugin can retry the process of establishing and negotiating that connection.

Range: 1 second or higher.

Default: 10 seconds

server_connection_negotiation_timeout

Timeout (in seconds) for negotiating a server data connection.

The TCP Transport plugin requires some negotiation before establishing a connection. This property controls the maximum time (in seconds) a server data connection negotiation can remain in progress.

In particular, it controls a maximum timeout for requesting and replying to a client logical port request.

If the negotiation of a connection has not completed after the specified timeout, the negotiation will restart, and if there is an associated data connection, it will be closed. This way, the TCP Transport plugin can retry the process of establishing and negotiating that connection.

Range: 1 second or higher.

Default: 10 seconds

initial_handshake_timeout

Timeout (in seconds) for the initial handshake for a connection.

Once a connection is established, TCP transport will exchange some information to identify itself and the connection. This process is known as the initial handshake of a connection, and if using TLS the TCP Transport plugin will also exchange additional information to secure the connection.

This property controls the maximum time (in seconds) the initial handshake for a connection can remain in progress. If the handshake has not completed after the specified timeout, the connection will be closed. This way, the TCP Transport plugin can restart the process of establishing and handshaking that connection.

Range: 1 second or higher.

Default: 10 seconds

tls.verify.ca_file

A string that specifies the name of file containing Certificate Authority certificates. File should be in PEM format. See the OpenSSL manual page for SSL_load_verify_locations for more information.

To enable TLS, ca_file or ca_path is required; both may be specified (at least one is required).

tls.verify.ca_path

A string that specifies paths to directories containing Certificate Authority certificates. Files should be in PEM format and follow the OpenSSL-required naming conventions. See the OpenSSL manual page for SSL_CTX_load_verify_locations for more information.

To enable TLS, ca_file or ca_path is required; both may be specified (at least one is required).

tls.verify.verify_depth

Maximum certificate chain length for verification.

tls.verify.crl_file

Name of the file containing the Certificate Revocation List.

File should be in PEM format.

tls.identity.certificate_chain

String containing an identifying certificate (in PEM format) or certificate chain (appending intermediate CA certs in order).

An identifying certificate is required for secure communication. The string must be sorted starting with the certificate to the highest level (root CA). If this is specified, certificate_chain_file must be empty.

tls.identity.certificate_chain_file

File containing identifying certificate (in PEM format) or certificate chain (appending intermediate CA certs in order).

An identifying certificate is required for secure communication. The file must be sorted starting with the certificate to the highest level (root CA). If this is specified, certificate_chain must be empty.

Optionally, a private key may be appended to this file. If no private key option is specified, this file will be used to load a private key.

tls.identity.private_key_password

A string that specifies the password for private key.

tls.identity.private_key

String containing private key (in PEM format).

At most one of private_key and private_key_file may be specified. If no private key is specified (all values are NULL), the private key will be read from the certificate chain file.

tls.identity.private_key_file

File containing private key (in PEM format).

At most one of private_key and private_key_file may be specified. If no private key is specified (all values are NULL), the private key will be read from the certificate chain file.

tls.identity.rsa_private_key

String containing additional RSA private key (in PEM format).

For use if both an RSA and non-RSA key are required for the selected cipher. At most one of rsa_private_key and rsa_private_key_file may be specified.

At most one of rsa_private_key and rsa_private_key_file may be specified.

tls.identity.rsa_private_key_file

File containing additional RSA private key (in PEM format).

For use if both an RSA and non-RSA key are required for the selected cipher. At most one of rsa_private_key and rsa_private_key_file may be specified.

At most one of rsa_private_key and rsa_private_key_file may be specified.

tls.cipher.cipher_list

List of available (D)TLS ciphers. See the OpenSSL manual page for SSL_set_cipher_list for more information on the format of this string.

tls.cipher.dh_param_files

List of available Diffie-Hellman (DH) key files. For example: "foo.h:2048,bar.h:1024" means:

dh_param_files[0].file = foo.pem,
dh_param_files[0].bits = 2048,
dh_param_files[1].file = bar.pem,
dh_param_files[1].bits = 1024

tls.cipher.engine_id

ID of OpenSSL cipher engine to request.

disable_interface_tracking

If this variable is set, the automatic change detection over the system network interfaces will be disabled.

See Setting Builtin Transport Properties with the PropertyQosPolicy in Setting Builtin Transport Properties with the PropertyQosPolicy

Connection Liveliness

The connection_liveliness property configures the connection liveliness feature. When enabled, the TCP Transport plugin will periodically exchange some additional control traffic (liveliness requests/responses) over one of the connections between the TCP Client and Server. This traffic allows determining if a that connection is not alive anymore, and thus proceed to its close. This avoids depending on the OS notification about the status of the connection, potentially decreasing the time to reestablish lost connections.

The following parameters can be configured:

This feature relies on the creation on an additional thread in the TCP Transport Plugin (the event thread). For more information about how to configure this thread, see the event_thread in Properties for NDDS_Transport_TCPv4_Property_t.

Enabling this feature breaks backwards compatibility with TCP Transport plugins that do not include this feature.

© 2018 RTI