Required

Comma-separated strings indicating the prefix names of all plugins that will be loaded by Connext. 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.

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 Linux systems, Path on Windows systems, DYLD_LIBRARY_PATH on macOS systems).

Only required if linking dynamically

If used, must be “NDDS_Transport_TCPv4_create”.

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.

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.

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.

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".

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.

Specifies the maximum number of buffers that Connext 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 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 from trying to gather too many buffers into a send call for the transport plugin.

Connext 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

The maximum size of a message in bytes that can be sent or received by the transport plugin. Above this size, DDS-level fragmentation will occur. See 34.3 Large Data Fragmentation.

Default: 65536

A list of strings, each identifying a range of interface addresses or an interface name 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. The DomainParticipant will use the resulting list of interfaces to inform its remote participant(s) about which unicast addresses may be used to send data to that DomainParticipant.

You must manage the memory of the list. The memory may be freed after the DomainParticipant is deleted.

The left-to-right order of this list matters if you are using the max_interface_count to limit the allowable interfaces further. See max_interface_count.

Default: empty list that represents all available interfaces

A list of strings, each identifying a range of interface addresses or an interface name 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 for receiving data.

You must manage the memory of the list. The memory may be freed after the DomainParticipant is deleted.

Default: empty list that represents no denied interfaces

How many of the addresses in your allowed interfaces list are used, at most, at any time.

This feature is useful if you want to control the network interfaces on which your DomainParticipants receive data. For example, if you have one wired and one wireless interface in your allowed interfaces list both up and running, and max_interface_count is set to 1, the DomainParticipant will receive data over the interface you list first in the allow_interfaces_list—for example, the wired one. If the wired interface is not in use (for example, the device is undocked), then the DomainParticipant will receive data only over the next available up-and-running interface in your allow_interfaces_list, which would be the wireless one.

Connext selects the preferred interface(s) by iterating over the list of allowed interfaces until the first max_interfaces_count of active interfaces encountered are announced. The order of iteration is left to right as specified in the allow_interfaces_list setting.

This setting applies only if the allow_interfaces_list is not empty.

The max_interface_count setting does not consider end-to-end connectivity to select interfaces. The decision is based purely on whether interfaces are up or down in a node. Therefore, this feature is not intended to be used in the following scenarios:

• A DomainParticipant is not reachable by other DomainParticipants in all the interfaces in the allow_interfaces_list. This could occur if the DomainParticipant is in different subnets, and some of these subnets cannot be reached by other DomainParticipants.
• End-to-end connectivity issues lead to situations in which the interfaces selected after applying max_interface_count cannot be reached by other DomainParticipants.

Note: If a pattern string in the allow_interfaces_list matches multiple interface addresses, and max_interface_count is set to a finite value, the order for the matching allowed interfaces is decided based on the order in which the operating system provides these interfaces.

Default: LENGTH_UNLIMITED

Range: [1, LENGTH_UNLIMITED]

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. The maximum value is operating system-dependent.

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

Default: 131072

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. The maximum value is operating-system dependent.

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

Default: 131072

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

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

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

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

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

See interface_poll_period in 51.6 Setting Builtin Transport Properties with the PropertyQosPolicy

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

Default: 5

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.

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.

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

If this property is set to zero (which is only a valid configuration when parent.classid is NDDS_TRANSPORT_CLASSID_TCPV4_WAN or NDDS_TRANSPORT_CLASSID_TLSV4_WAN), the transport will operate in "asymmetric mode" and it 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 more information about the available modes of operation for the transport, please refer to 53.1 TCP Communication Scenarios.

For WAN communication, if server_bind_port is set to a value other than zero, 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

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)

Allocation settings applied to buffers used for asynchronous (non-blocking) send. To enable asynchronous send, set the property force_asynchronous_send to 1.

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 = 32
• write_buffer_allocation.incremental_count = 2

The pool of buffers can be configured to be shared across all the TCP connections created by the TCP Transport or to be exclusive for a connection by setting the property shared_write_buffer_allocation to 1. The default value is 0.

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, a new message will replace the oldest message that is not currently in the process of being sent. This guarantees that new messages are prioritized, while at the same time not running into a situation in which messages are not received. Messages that are replaced and not sent may be resent later depending on the application's QoS (if the transport is used for reliable communication, the data will still be sent eventually).

This property determines whether the pool of buffers created with asynchronous (non-blocking) send is shared or exclusive per TCP connection. Sharing this buffer across connections may lead to less memory consumption. However, high-throughput connections may starve low-throughput connections. This is why the default value is 0. The size of the buffer pool can be configured using the property write_buffer_allocation.

Default: 0

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)

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)

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)

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 in an internal send buffer and enqueue it. Data will be sent as soon as the low-level socket buffer has space.

Setting this option to 0 (default) should provide better latency. However, in high-throughput scenarios, a 0 setting 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, the 0 setting 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).

The size of the buffer pool created by setting this option to 1 can be configured using the property write_buffer_allocation. In addition, the TCP Transport can be used to create one buffer pool per connection or a single buffer pool shared across all TCP connections by using the property shared_write_buffer_allocation.

Default: 0

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)

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.

Default: 0

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)

Specifies the interval in seconds between KEEP_ALIVE retries.

This parameter is only supported on Linux architectures.

Default: -1 (OS default value)

The maximum number of KEEP_ALIVE retries before dropping the connection.

This parameter is only supported on Linux architectures.

Default: -1 (OS default value)

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).

Configures the connection liveliness feature. See 53.2.7.1 Connection Liveliness.

Defaults:

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

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

Defaults:

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

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

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

Logging values:

• -1 (0xffffffff): do not change the current verbosity
• 0x00: silence
• 0x01: fatal error
• 0x02: errors
• 0x04: warnings
• 0x08: local
• 0x10: remote
• 0x20: periodic
• 0x100: other (used for control protocol tracing)
• 13F: all (fatal error, errors, warnings, local, remote, periodic, and other)

You can combine these values by logically ORing them together.

Default: -1 (meaning, do not change the current verbosity, which is fatal errors, errors, and warnings by default)

Note: the logging verbosity is a global property shared across the multiple instances of the TCP Transport within an application. 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.

Note: The option of 0x100 (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).

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

Logging values:

• -1 (0xffffffff): use the current verbosity of the transport, which is a global property (see logging_verbosity_bitmap)
• 0x00: silence
• 0x01: fatal error
• 0x02: errors
• 0x04: warnings
• 0x08: local
• 0x10: remote
• 0x20: periodic

You can combine these values by logically ORing them together.

Default: -1 (use the current verbosity of the transport, which is a global property (see logging_verbosity_bitmap))

Note: The security logging verbosity is a global property shared across the multiple instances of the TCP Transport within an application. If you create a new TCP Transport instance, the value of security_logging_verbosity_bitmap will be applied to all the other instances as well.

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.

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.thread_pool_size: 2

windows_iocp.concurrency_value: 1

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

Default: 0

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

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 applications. This keeps the connections from being divided among multiple servers and ensures proper communication.

For more information about this property, see 53.2.6 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.

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

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).

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 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.

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

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

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

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).

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.

The Certificate Authority subject name hash values must be available in the directories. You may generate them by running openssl rehash (available in OpenSSL 1.1.0 or above) in each directory.

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

Maximum certificate chain length for verification.

Name of the file containing the Certificate Revocation List.

File should be in PEM format.

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.

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.

A string that specifies the password for 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.

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.

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.

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.

List of available TLS ciphers when communicating with Connext 6.0.0 or below. See the OpenSSL manual page for SSL_set_cipher_list for more information on the format of this string.

Default: NULL

List of available TLS ciphersuites when communicating with Connext 6.0.1 or above. See the OpenSSL manual page for SSL_CTX_set_ciphersuites for more information on the format of this string.

Default: NULL

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

ID of OpenSSL cipher engine to request.

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

See disable_interface_tracking in 51.6 Setting Builtin Transport Properties with the PropertyQosPolicy

This property forces the interface tracker to use a polling method to detect changes to the network interfaces in IP mobility scenarios. It only applies to operating systems that support asynchronous notifications of interface changes.

If set to TRUE, the interface tracker will use a polling method that queries the interfaces periodically to detect the changes. If set to FALSE, the interface tracker will use the operating system’s default method.

Basically, this property allows you—for an operating system that supports asynchronous notification—to use the polling method instead.

Default: FALSE

By default, property names given in the 47.19 PROPERTY QosPolicy (DDS Extension) are validated to avoid using incorrect or unknown names (for example, due to a typo). This property configures the validation of the property names associated with the transport:

• VALIDATION_ACTION_EXCEPTION: validate the properties. Upon failure, log errors and fail.
• VALIDATION_ACTION_SKIP: skip validation.
• VALIDATION_ACTION_WARNING: validate the properties. Upon failure, log warnings and do not fail.

If this property is not set, the property validation behavior will be the same as that of the DomainParticipant, which by default is VALIDATION_ACTION_EXCEPTION. See 47.19.1 Property Validation for more information.