TCP level socket option setter/getter helper. More...

#include <TCPOptions.hxx>

Inheritance diagram for cosmos::TCPOptions:

Public Member Functions
void	setCongestionControl (const SysString name)
	Select the TCP congestion control algorithm on a per-socket basis.

void	setCork (const bool on_off)
	Don't send out partial frames.

void	pushCork ()

void	popCork ()

void	setDeferAccept (const std::chrono::seconds max_wait)
	Allow a listener to be awakened only when data arrives on the socket.

TCPInfo	getInfo () const
	Returns a structure containing detailed state about the TCP socket.

void	setKeepaliveCount (const size_t count)
	Sets the maximum number of keepalive probes before dropping the connection.

void	setKeepaliveIdleTime (const std::chrono::seconds idle_time)
	Sets the amount of connection idle time before the keepalive algorithm sets in.

void	setKeepaliveInterval (const std::chrono::seconds interval)
	Sets the time span between individual keepalive probes.

void	setFinLinger (const std::chrono::seconds timeout)
	Sets the timeout in seconds for orphaned sockets to stay in FIN_WAIT2 state.

void	setMaxSegmentSize (const size_t bytes)
	Sets the maximum segment size for outgoing TCP packets.

void	setNoDelay (const bool on_off)
	Disable the Nagle algorithm (accumulating data before sending).

void	setQuickACK (const bool on_off)
	Enable or disable quick ACK mode.

void	setSynCount (const size_t count)
	Set the number of SYN retransmits before aborting a connection attempt.

void	setUserTimeout (const std::chrono::milliseconds timeout)
	Maximum time that the TCP protocol is allowed to be stuck without terminating the connection.

void	setWindowClamp (const size_t bytes)
	Bound the size of the advertised transmission window.

void	setFastOpen (const size_t max_pending_syns)
	Enable TCP fast open (RFC 7413) on this socket.

void	setFastOpenConnect (const bool on_off)
	Enable TCP fast open for the `connect()` system call.

Protected Member Functions
	SockOptBase (FileDescriptor fd)
	Perform socket options on the given file descriptor.

	SockOptBase (const SockOptBase &)=delete

Protected Member Functions inherited from cosmos::SockOptBase< OptLevel::TCP >
	SockOptBase (FileDescriptor fd)
	Perform socket options on the given file descriptor.

	SockOptBase (const SockOptBase &)=delete

bool	getBoolOption (const OptName name) const
	Return a boolean style option.

void	setBoolOption (const OptName name, const bool val)
	Set a boolean style option.

int	getIntOption (const OptName name) const
	Return an integer option.

void	setIntOption (const OptName name, const int val)
	Set an integer option.

std::string	getStringOption (const OptName name, size_t max_len) const
	Return a null terminated string option.

void	setStringOption (const OptName name, const SysString str)
	Set a null terminated string option.

std::string	getPeerSec () const
	Returns the labeled IPSEC or NetLabel of the peer.

SockOptBase &	operator= (const SockOptBase &)=delete

Friends
template<SocketFamily family>
class	TCPListenSocketT

template<SocketFamily family>
class	TCPClientSocketT

template<SocketFamily family>
class	TCPConnectionT

Additional Inherited Members
Protected Attributes inherited from cosmos::SockOptBase< OptLevel::TCP >
FileDescriptor	m_sock
	The socket file descriptor to operate on.

Static Protected Attributes inherited from cosmos::SockOptBase< OptLevel::TCP >
static constexpr OptLevel	M_LEVEL
	The option level to operate on.

Detailed Description

TCP level socket option setter/getter helper.

Definition at line 17 of file TCPOptions.hxx.

Member Function Documentation

◆ getInfo()

TCPInfo cosmos::TCPOptions::getInfo ( ) const

Returns a structure containing detailed state about the TCP socket.

Definition at line 7 of file TCPOoptions.cxx.

                                  {
        return getsockopt<TCPInfo>(m_sock, M_LEVEL, OptName{TCP_INFO});
}

◆ popCork()

void cosmos::TCPOptions::popCork ( )

inline

Definition at line 57 of file TCPOptions.hxx.

                       {
                setCork(false);
        }

◆ pushCork()

void cosmos::TCPOptions::pushCork ( )

inline

Definition at line 53 of file TCPOptions.hxx.

                        {
                setCork(true);
        }

◆ setCongestionControl()

void cosmos::TCPOptions::setCongestionControl ( const SysString name )

inline

Select the TCP congestion control algorithm on a per-socket basis.

Unprivileged processes can select any of the algorithms listed in the "tcp_allowed_congestion_control" sysctl. Processes with CAP_NET_ADMIN can select any of the algorithms listed in the "tcp_available_congestion_control" sysctl.

Definition at line 38 of file TCPOptions.hxx.

                                                        {
                setStringOption(OptName{TCP_CONGESTION}, name);
        }

◆ setCork()

void cosmos::TCPOptions::setCork ( const bool on_off )

inline

Don't send out partial frames.

This accumulates data for bulk sending until the setting is disabled again. This can be useful to prepend headers before sending the payload or for improving throughput. There is currently a 200 ms ceiling for this setting after which data will be sent out anyway.

Definition at line 49 of file TCPOptions.hxx.

                                        {
                setBoolOption(OptName{TCP_CORK}, on_off);
        }

◆ setDeferAccept()

void cosmos::TCPOptions::setDeferAccept ( const std::chrono::seconds max_wait )

inline

Allow a listener to be awakened only when data arrives on the socket.

This reduces the number of TCP exchanges by not reacting to client side ACK packets, but waiting for the first actual data packet, before the connection is considered established. If this shortcut does not work for the given number of seconds then a fallback to the original behaviour is made to allow the connection to be established.

This option is designed to reduce the latency for connection establishment e.g. in short lived TCP connections like the HTTP protocol.

Definition at line 74 of file TCPOptions.hxx.

                                                             {
                setIntOption(OptName{TCP_DEFER_ACCEPT}, max_wait.count());
        }

◆ setFastOpen()

void cosmos::TCPOptions::setFastOpen ( const size_t max_pending_syns )

inline

Enable TCP fast open (RFC 7413) on this socket.

This setting specifies the maximum length of pending SYNs on the listener socket. With this option enabled accept() can return a socket available for read and write without the TCP connection handshake being completed.

For the client side equivalent for this see MessageFlag::FASTOPEN and setFastOpenConnect().

Definition at line 214 of file TCPOptions.hxx.

                                                        {
                setIntOption(OptName{TCP_FASTOPEN}, max_pending_syns);
        }

◆ setFastOpenConnect()

void cosmos::TCPOptions::setFastOpenConnect ( const bool on_off )

inline

Enable TCP fast open for the connect() system call.

If a cookie is available for the destination during connect() time, then the kernel won't send out a SYN, but returns a connected socket immediately. The actual connection will only be established once data is written over the socket.

This has implications on the behaviour of the socket:

if no write() is performed, but only a read() then this socket will block indefinitely (because the connection is not established).
read() and write() can return different errors than before, because the connection may yet fail to be established.

The order of calls with this option should always be similar to this:

sock.setFastOpenConnect(true);
sock.connect(...);
sock.write(...); // trigger SYN + data going out.

Definition at line 240 of file TCPOptions.hxx.

                                                   {
                setBoolOption(OptName{TCP_FASTOPEN_CONNECT}, on_off);
        }

◆ setFinLinger()

void cosmos::TCPOptions::setFinLinger ( const std::chrono::seconds timeout )

inline

Sets the timeout in seconds for orphaned sockets to stay in FIN_WAIT2 state.

This is different from the SocketOption::setLinger() setting. It is concerned with closed TCP connections that haven't yet left the FIN_WAIT2 state. This timeout determines the maximum wait time before the state if forcibly changed.

Definition at line 114 of file TCPOptions.hxx.

                                                          {
                setIntOption(OptName{TCP_LINGER2}, timeout.count());
        }

◆ setKeepaliveCount()

void cosmos::TCPOptions::setKeepaliveCount ( const size_t count )

inline

Sets the maximum number of keepalive probes before dropping the connection.

Definition at line 83 of file TCPOptions.hxx.

                                                   {
                setIntOption(OptName{TCP_KEEPCNT}, count);
        }

◆ setKeepaliveIdleTime()

void cosmos::TCPOptions::setKeepaliveIdleTime ( const std::chrono::seconds idle_time )

inline

Sets the amount of connection idle time before the keepalive algorithm sets in.

This is relevant if SocketOptions::setKeepalive() is enabled. This option sets the number of seconds of idle time (no exchange happened on the connection) before the keepalive algorithm starts doings its thing.

Definition at line 94 of file TCPOptions.hxx.

                                                                    {
                setIntOption(OptName{TCP_KEEPIDLE}, idle_time.count());
        }

◆ setKeepaliveInterval()

void cosmos::TCPOptions::setKeepaliveInterval ( const std::chrono::seconds interval )

inline

Sets the time span between individual keepalive probes.

When the keepalive algorithm is running then this setting defines the time in seconds between individual keepalive probes being sent.

Definition at line 103 of file TCPOptions.hxx.

                                                                   {
                setIntOption(OptName{TCP_KEEPINTVL}, interval.count());
        }

◆ setMaxSegmentSize()

void cosmos::TCPOptions::setMaxSegmentSize ( const size_t bytes )

inline

Sets the maximum segment size for outgoing TCP packets.

If this is set before a TCP connection is established then this also changes the MSS value announced to the other end of the connection.

This setting is bound by the actual interface MTU on the lower level. If the TCP MSS is greater than the MTU, then the MSS will be ignored.

Definition at line 128 of file TCPOptions.hxx.

                                                   {
                setIntOption(OptName{TCP_MAXSEG}, bytes);
        }

◆ setNoDelay()

void cosmos::TCPOptions::setNoDelay ( const bool on_off )

inline

Disable the Nagle algorithm (accumulating data before sending).

By default TCP accumulates multiple smaller packets before sending them over the wire, to optimize throughput. This can be problematic for interactive applications (e.g. character wise transmission of characters in terminal applications).

By disabling this behaviour interactive applications become responsive, but the throughput might suffer. This option can be overriden by using setCork(). Setting the nodelay option causes an immediate flush, though, even if the cork is currently set.

Definition at line 144 of file TCPOptions.hxx.

                                           {
                setBoolOption(OptName{TCP_NODELAY}, on_off);
        }

◆ setQuickACK()

void cosmos::TCPOptions::setQuickACK ( const bool on_off )

inline

Enable or disable quick ACK mode.

In quick ACK mode ACKs are sent out immediately, rather than delayed in accordance with normal TCP operation. This setting is not permanent but only influences the current state, which might change again depending on the internal TCP protocol processing.

Definition at line 155 of file TCPOptions.hxx.

                                            {
                setBoolOption(OptName{TCP_QUICKACK}, on_off);
        }

◆ setSynCount()

void cosmos::TCPOptions::setSynCount ( const size_t count )

inline

Set the number of SYN retransmits before aborting a connection attempt.

This cannot exceed 255.

Definition at line 163 of file TCPOptions.hxx.

                                             {
                setIntOption(OptName{TCP_SYNCNT}, count);
        }

◆ setUserTimeout()

void cosmos::TCPOptions::setUserTimeout ( const std::chrono::milliseconds timeout )

Maximum time that the TCP protocol is allowed to be stuck without terminating the connection.

This affects the sending side of the protocol. If data remains unacknowledged or buffered data remains untransmitted (due to a zero window size) for the given amount of time, then the connection will be forcibly closed and an error of Errno::TIMEDOUT will be reported to the application.

If set to zero then the system default will be applied, which will keep a typical WAN connection alive for 20 minutes even if no progress is made. The tuning of this parameter can allow connections to recover even after a long time, or to fail quickly in case of network errors.

The option can be set in any state of the TCP connection, but only applies in certain TCP connection states like ESTABLISHED. This setting will override the TCP connection keepalive settings, if both are enabled.

If set on a TCP Listening socket then this setting will be inherited by connections that are accept()'ed.

Definition at line 11 of file TCPOoptions.cxx.

                                                                   {
        setsockopt(m_sock, M_LEVEL, OptName{TCP_USER_TIMEOUT}, static_cast<unsigned int>(timeout.count()));
}

◆ setWindowClamp()

void cosmos::TCPOptions::setWindowClamp ( const size_t bytes )

inline

Bound the size of the advertised transmission window.

The TCP window size determines how much data will be sent before the other end needs to transmit an ACK packet.

This socket options sets an upper bound to this window size. The Linux kernel imposes a minimum size of half the size of the SOCK_MIN_RCVBUF option, though.

Definition at line 200 of file TCPOptions.hxx.

                                                {
                setIntOption(OptName{TCP_WINDOW_CLAMP}, bytes);
        }

◆ SockOptBase()

cosmos::SockOptBase< LEVEL >::SockOptBase ( FileDescriptor fd )

inlineexplicitprotected

Perform socket options on the given file descriptor.

Definition at line 22 of file SockOptBase.hxx.

22 :

23 m_sock{fd} {}

Friends And Related Symbol Documentation

◆ TCPClientSocketT

template<SocketFamily family>

friend class TCPClientSocketT

friend

Definition at line 24 of file TCPOptions.hxx.

◆ TCPConnectionT

template<SocketFamily family>

friend class TCPConnectionT

friend

Definition at line 27 of file TCPOptions.hxx.

◆ TCPListenSocketT

template<SocketFamily family>

friend class TCPListenSocketT

friend

Definition at line 21 of file TCPOptions.hxx.

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

include/net/TCPOptions.hxx
src/net/TCPOoptions.cxx

Public Member Functions

Protected Member Functions

Friends

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ getInfo()

◆ popCork()

◆ pushCork()

◆ setCongestionControl()

◆ setCork()

◆ setDeferAccept()

◆ setFastOpen()

◆ setFastOpenConnect()

◆ setFinLinger()

◆ setKeepaliveCount()

◆ setKeepaliveIdleTime()

◆ setKeepaliveInterval()

◆ setMaxSegmentSize()

◆ setNoDelay()

◆ setQuickACK()

◆ setSynCount()

◆ setUserTimeout()

◆ setWindowClamp()

◆ SockOptBase()

Friends And Related Symbol Documentation

◆ TCPClientSocketT

◆ TCPConnectionT

◆ TCPListenSocketT