Specific use of nginx keepalive

sk->keepalive_probes: number of probes, number of retries sk->keepalive_time: heartbeat interval of the probe, after how many seconds the TCP link starts the probe message without data packet transmission sk->keepalive_intvl: probe interval, the time interval between retries when no reply is received

[***@*** ~]$ cat /proc/sys/net/ipv4/tcp_keepalive_time
7200
[***@*** ~]$ cat /proc/sys/net/ipv4/tcp_keepalive_intvl
75
[***@*** ~]$ cat /proc/sys/net/ipv4/tcp_keepalive_probes
9

int keepalive = 1; // Enable the keepalive attribute int keepidle = 60; // If there is no data exchange within 60 seconds, a detection is performed int keepinterval = 5; // The interval between sending packets during detection is 5 seconds int keepcount = 3; // The number of detection attempts. If a response is received after the first detection packet, the next two detection packets will not be sent. And clear the count setsockopt(rs, SOL_SOCKET, SO_KEEPALIVE, (void *)&keepalive, sizeof(keepalive));
setsockopt(rs, SOL_TCP, TCP_KEEPIDLE, (void*)&keepidle, sizeof(keepidle));
setsockopt(rs, SOL_TCP, TCP_KEEPINTVL, (void *)&keepinterval, sizeof(keepinterval));
setsockopt(rs, SOL_TCP, TCP_KEEPCNT, (void *)&keepcount, sizeof(keepcount));

typedef struct _TCP_HEADER
{
 short m_sSourPort; // Source port number 16bit
 short m_sDestPort; // destination port number 16bit
 unsigned int m_uiSequNum; //req field sequence number 32bit
 unsigned int m_uiAcknowledgeNum; //ack field confirmation number 32bit
 short m_sHeaderLenAndFlag; // The first 4 bits: TCP header length; the middle 6 bits: reserved; the last 6 bits: flag short m_sWindowSize; //win field window size 16 bits
 short m_sCheckSum; // Checksum 16bit
 short m_surgentPointer; // Emergency data offset 16 bits
}__attribute__((packed))TCP_HEADER, *PTCP_HEADER;

0000 d4 6d 50 f5 02 7f f4 5c 89 cb 35 29 08 00 // MAC header 14 bytes:
                         45 00 // IP header 20 bytes:
0010 00 28 10 f4 00 00 40 06 5b dd ac 19 42 76 0a b3
0020 14 bd
      e4 4a 1f 7c 32 7e 7a cb 4c bc 55 08 50 10 // TCP header 20 bytes 0030 10 00 3f 00 00 00
//Analyze the TCP header content e4 4a //The source port number 16bit decimal is: 58442 
1f 7c //Destination port number 16bit decimal: 8060 
32 7e 7a cb // The 32-bit serial number of the req field is in decimal: 
4c bc 55 08 // ack field confirmation number 32 bits 
5 // First 4 bits: TCP header length 5*4 = 20 bytes, no problem 0 10 /// Middle 6 bits: reserved; last 6 bits: flag bit 10 represents the 5th bit from the end is 1, marking the change of TCP packet to ACK confirmation packet 0030 10 00 3f 00 00 00

0000 f4 5c 89 cb 35 29 d4 6d 50 f5 02 7f 08 00 45 00 
0010 00 34 47 28 40 00 36 06 ef 9c 0a b3 14 bd ac 19 
0020 42 76 // The previous data is not interpreted 1f 7c
e4 4a
4c bc 55 08
32 7e 7a cc
8 // The length of the TCP header is 8 * 4 = 32. In addition to the header, there are 12 bytes of option data. 0 10 // The middle 6 bits are reserved; the last 6 bits are flag bits. 10 represents the 5th bit from the end is 1, indicating that the TCP packet is an ACK confirmation packet. 0030 01 3f // The win field window size is 16 bits.
4e 0d // Checksum 16bit
00 00 // Emergency data offset 16 bits
01 01 08 0a 00 59 be 1c 39 13 
0040 cf 12 // Option data 12 bytes

The first thing to do is to determine the version: when the http protocol version is lower than 1.1, the keepalive of the link is set to 0
if (r->http_version < NGX_HTTP_VERSION_11) {
  r->keepalive = 0;
} 
In the ngx_http_process_connection function, if ngx_http_request_t has keep-alive, mark the link if (ngx_strcasestrn(h->value.data, "keep-alive", 10 - 1)) {
  r->headers_in.connection_type = NGX_HTTP_CONNECTION_KEEP_ALIVE;
}
In the ngx_http_handler function, r->headers_in.connection_type is judged and r->keepalive is assigned a value of 1
  switch (r->headers_in.connection_type) {
  case NGX_HTTP_CONNECTION_KEEP_ALIVE:
    r->keepalive = 1;
    break;
  }
In the ngx_configure_listening_sockets function, when keepalive is 1, KEEPALIVE is enabled for the connection. After that, the underlying TCP layer will detect dead connections for the connection fd, maintain a long connection, and not disconnect.
if (ls[i].keepalive) {
  value = (ls[i].keepalive == 1) ? 1 : 0;

  if (setsockopt(ls[i].fd, SOL_SOCKET, SO_KEEPALIVE,//Enable keepalive function (const void *) &value, sizeof(int))
    == -1)
  
}

keepalive_timeout timeout [header_timeout];