Implementation of socket options in Linux network programming

Socket option function

Function: Methods used to read and set socket file descriptor attributes

#include <sys/scoket.h>
int getsockopt ( int sockfd, int level, int option_name, void* option_value, socklen_t* restrict option_len );
int setsockopt ( int sockfd, int level, int option_name, const void* option_value, socklen_t option_len);

The socket option table is as follows:

The getsockopt and setsockopt functions return 0 on success and -1 and set errno on failure.

For the server, some socket options are only valid if they are set for the listening socket before calling the listen system call. This is because the connection socket can only be returned by the accept call, and the connection accepted by accept from the listen queue has at least completed the first two steps of the TCP three-way handshake (because the connection in the listen queue has at least entered the SYN_RCVD state), which means that the server has sent a TCP synchronization segment to the received connection. However, some socket options should be set in the TCP synchronization segment, such as the TCP maximum segment option. For this situation, the solution that Linux provides to developers is: set these socket options for the listening socket, and then the connection socket returned by accept will automatically inherit these options. These options are: SO_DEBUG, SO_DONTROUTE, SO_KEEPALIVE, SO_LINGER, SO_OOBINLINE, SO_RCVBUF, SO_RCVLOWAT, SO_SNDBUF, SO_SNDLOWAT, TCP_MAXSEG, and TCP_NODELAY.

For the client, these socket options should be set before calling the connect function, because after the connect call returns successfully, the TCP three-way handshake is completed.

SO_REUSEADDR Option

We have discussed the TIME_WAIT state of TCP connections before, and mentioned that the server program can force the use of the socket address occupied by the connection in the TIME_WAIT state by setting the socket option SO_REUSEADDR.

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
 
int main( int argc, char* argv[] )
{
  if( argc <= 2 )
  {
    printf( "usage: %s ip_address port_number\n", basename( argv[0] ) );
    return 1;
  }
  const char* ip = argv[1];
  int port = atoi( argv[2] );
 
  int sock = socket( PF_INET, SOCK_STREAM, 0 );
  assert( sock >= 0 );
  int reuse = 1;
  setsockopt( sock, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof( reuse ) );
 
  struct sockaddr_in address;
  bzero( &address, sizeof( address ) );
  address.sin_family = AF_INET;
  inet_pton( AF_INET, ip, &address.sin_addr );
  address.sin_port = htons( port );
  int ret = bind( sock, ( struct sockaddr* )&address, sizeof( address ) );
  assert( ret != -1 );
 
  ret = listen( sock, 5 );
  assert( ret != -1 );
 
  struct sockaddr_in client;
  socklen_t client_addrlength = sizeof( client );
  int connfd = accept( sock, ( struct sockaddr* )&client, &client_addrlength );
  if ( connfd < 0 )
  {
    printf( "errno is: %d\n", errno );
  }
  else
  {
    char remote[INET_ADDRSTRLEN ];
    printf( "connected with ip: %s and port: %d\n", 
      inet_ntop( AF_INET, &client.sin_addr, remote, INET_ADDRSTRLEN ), ntohs( client.sin_port ) );
    close( connfd );
  }
 
  close( sock );
  return 0;
}

After setsocketopt is set, even if the sock is in TIME_WAIT state, the socket address bound to it can be reused immediately. In addition, we can also quickly recycle closed sockets by modifying the kernel parameter /proc/sys/net/ipv4/tcp_tw_recycle so that the TCP connection does not enter the TIME_WAIT state at all, allowing the application to reuse the local socket address immediately.

SO_RCVBUF and SO_SNDBUF Options

The SO_RCVBUF and SO_SNDBUF options represent the sizes of the TCP receive buffer and send buffer, respectively. However, when we use setsockopt to set the size of TCP's receive buffer and send buffer, the system will double its value and it must not be less than its minimum value. The minimum value for the TCP receive buffer is 256 bytes, and the minimum value for the send buffer is 2048 bytes (however, different systems may have different default minimum values). In addition, we can directly modify the kernel parameters /proc/sys/net/ipv4/tcp_rmem and /proc/sys/net/ipv4/tcp_wmem to force the TCP receive buffer and send buffer to have no minimum size limit.

Modify the client program of TCP send buffer:

#include <sys/socket.h>
#include <arpa/inet.h>
#include <assert.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
 
#define BUFFER_SIZE 512
 
int main( int argc, char* argv[] )
{
  if( argc <= 3 )
  {
    printf( "usage: %s ip_address port_number send_bufer_size\n", basename( argv[0] ) );
    return 1;
  }
  const char* ip = argv[1];
  int port = atoi( argv[2] );
 
  struct sockaddr_in server_address;
  bzero( &server_address, sizeof( server_address ) );
  server_address.sin_family = AF_INET;
  inet_pton( AF_INET, ip, &server_address.sin_addr );
  server_address.sin_port = htons( port );
 
  int sock = socket( PF_INET, SOCK_STREAM, 0 );
  assert( sock >= 0 );
 
  int sendbuf = atoi( argv[3] );
  int len ​​= sizeof( sendbuf );
  setsockopt( sock, SOL_SOCKET, SO_SNDBUF, &sendbuf, sizeof( sendbuf ) );
  getsockopt( sock, SOL_SOCKET, SO_SNDBUF, &sendbuf, ( socklen_t* )&len );
  printf( "the tcp send buffer size after setting is %d\n", sendbuf );
 
  if ( connect( sock, ( struct sockaddr* )&server_address, sizeof( server_address ) ) != -1 )
  {
    char buffer[ BUFFER_SIZE ];
    memset( buffer, 'a', BUFFER_SIZE );
    send( sock, buffer, BUFFER_SIZE, 0 );
  }
 
  close( sock );
  return 0;
}

Modify the server program of TCP receive buffer:

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
 
#define BUFFER_SIZE 1024
 
int main( int argc, char* argv[] )
{
  if( argc <= 3 )
  {
    printf( "usage: %s ip_address port_number receive_buffer_size\n", basename( argv[0] ) );
    return 1;
  }
  const char* ip = argv[1];
  int port = atoi( argv[2] );
 
  struct sockaddr_in address;
  bzero( &address, sizeof( address ) );
  address.sin_family = AF_INET;
  inet_pton( AF_INET, ip, &address.sin_addr );
  address.sin_port = htons( port );
 
  int sock = socket( PF_INET, SOCK_STREAM, 0 );
  assert( sock >= 0 );
  int recvbuf = atoi( argv[3] );
  int len ​​= sizeof( recvbuf );
  setsockopt( sock, SOL_SOCKET, SO_RCVBUF, &recvbuf, sizeof( recvbuf ) );
  getsockopt( sock, SOL_SOCKET, SO_RCVBUF, &recvbuf, ( socklen_t* )&len );
  printf( "the receive buffer size after settting is %d\n", recvbuf );
 
  int ret = bind( sock, ( struct sockaddr* )&address, sizeof( address ) );
  assert( ret != -1 );
 
  ret = listen( sock, 5 );
  assert( ret != -1 );
 
  struct sockaddr_in client;
  socklen_t client_addrlength = sizeof( client );
  int connfd = accept( sock, ( struct sockaddr* )&client, &client_addrlength );
  if ( connfd < 0 )
  {
    printf( "errno is: %d\n", errno );
  }
  else
  {
    char buffer[ BUFFER_SIZE ];
    memset( buffer, '\0', BUFFER_SIZE );
    while( recv( connfd, buffer, BUFFER_SIZE-1, 0 ) > 0 ){}
    close( connfd );
  }
 
  close( sock );
  return 0;
}

Running results:

root@iZbp1anc6yju2dks3nw5j0Z:~/test/socket# ./client 127.0.0.1 12345 2000
the tcp send buffer size after setting is 4608

root@iZbp1anc6yju2dks3nw5j0Z:~/test/socket# ./server 127.0.0.1 12345 50
the receive buffer size after setting is 2304

As explained above: When we use setsockopt to set the size of TCP's receive buffer and send buffer, the system will double its value and it must not be less than its minimum value.

SO_RCVLOWAT and SO_SNDLOWAT Options

• The SO_RCVLOWAT and SO_SNDLOWAT options represent the low water mark for the TCP receive buffer and send buffer, respectively. They are generally called by the I/O multiplexing system to determine whether the socket is readable or writable. When the total amount of readable data in the TCP receive buffer is greater than its low water mark, the I/O multiplexing system call will notify the application that it can read data from the corresponding socket; when the free space in the TCP send buffer (space where data can be written) is greater than its low water mark, the I/O multiplexing system call will notify the application that it can write data to the corresponding socket.
• By default, the TCP receive buffer low water mark and the TCP send buffer low water mark are both 1 byte.

SO_LINGER Option

The SO_LINGER option is used to control the behavior of the close system call when closing a TCP connection. By default, when we use the close system call to close a socket, close will return immediately, and the TCP module is responsible for sending the remaining data in the TCP send buffer corresponding to the socket to the other party.

When setting the value of the SO_LINGER option, we need to pass a linger type structure to the setsockopt (getsockopt) system call, which is defined as follows:

#include <sys/socket.h>
struct linger
{
  int l_onoff; //Turn on (non-0) or off (0) this option int l_linger; //linger time};

• Depending on the values ​​of the two member variables in the linger structure, the close system call may produce one of the following three behaviors:
• l_onoff is equal to 0. At this time, the SO_LINGER option has no effect and close closes the socket with the default behavior.
• l_onoff is not 0, l_linger is equal to 0. At this time, the close system call returns immediately, the TCP module will discard the remaining data in the TCP send buffer corresponding to the closed socket, and send a reset segment to the other party. Therefore, this situation provides a way for the server to abnormally terminate a connection. l_onoff is not 0, l_linger is greater than 0. The behavior of close at this time depends on two conditions: (1) whether there is any residual data in the TCP send buffer corresponding to the closed socket; (2) whether the socket is blocking or non-blocking. For a blocked socket, close will wait for a period of l_linger until the TCP module has sent all the remaining data and received confirmation from the other party. If the TCP module does not send all the remaining data and get confirmation from the other party during this period, the close system call will return -1 and set errno to EWOULDBLOCK. If the socket is non-blocking, close will return immediately. At this time, we need to determine whether the remaining data has been sent based on its return value and errno.

The above is the full content of this article. I hope it will be helpful for everyone’s study. I also hope that everyone will support 123WORDPRESS.COM.