listen的参数backlog的意义

实验环境：Ubuntu16.04，内核版本：4.4.0-59-generic

根据man listen得到的解释如下：

backlog参数定义了存放pending状态（挂起、护着搁置）的连接的队列的最大长度；如果在队列满的时候，一个连接请求到达，客户端可能会收到一个错误：ECONREFUSED。

然后man listen的下面有一个小提示：

现在backlog这个参数指示的是存放已经建立连接（established）并等待被accept的sockets的队列的长度。

没有完成的socket队列的长度可以通过 /proc/sys/net/ipv4/tcp_max_syn_backlog 这个参数来设置。

如果backlog参数大于 /proc/sys/net/core/somaxconn 的值，那么该值将被自动截断为somaxconn的值，它的值默认是128。

下面是我做的一个关于backlog的小实验：

tcpSvr端调用完listen后，sleep，

客户端根据参数，开启n个线程，每个线程都尝试与tcpSvr建立连接。

 /*
  * gcc -std=c99 -o tcpCli ./tcpCli.c -lpthread
  */
 #include <unistd.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <pthread.h>

 const int PORT = ;

 void* func(void *arg)
 {
     int fd = socket(AF_INET, SOCK_STREAM, );
     if (fd == -)
     {
         perror("socket");
         return (void*);
     }

     struct sockaddr_in addr;
     memset(&addr, , sizeof(addr));
     addr.sin_family = AF_INET;
     addr.sin_addr.s_addr = inet_addr("127.0.0.1");
     addr.sin_port = htons(PORT);

     // get send buffer size
     int iWBufSize;
     socklen_t optLen = sizeof(iWBufSize);
     getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &iWBufSize, &optLen);
     printf("Write buffer size = %d\n", iWBufSize);

     int iRBufSize;
     optLen = sizeof(iRBufSize);
     getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &iRBufSize, &optLen);
     printf("Read buffer size = %d\n", iRBufSize);

     if (connect(fd, (struct sockaddr*)&addr, sizeof(addr)) != )
     {
         perror("connect");
         return (void*);
     }

     char buf[] = "hello world!";
     int iCount = ;
     while ()
     {
         sprintf(buf, "%d", iCount);
         int iRet = send(fd, buf, strlen(buf), );
         if (iRet == -)
         {
             perror("sendto");
             break;
         }
         else
         {
             // printf("Send data len [%d]\n", iRet);
             iCount++;
         }
         if (iCount %  == )
         {
             // printf("Send package count %d\n", iCount);
             sleep();
         }
     }
     printf("Send package count %d\n", iCount);
     close(fd);

     return (void*);
 }
 int main(int argc, char **argv)
 {
     if (argc != )
     {
         printf("Usage:%s thread_num\n", argv[]);
         return ;
     }

     int iThreadNum = atoi(argv[]);
     printf("ThreadNum [%d]\n", iThreadNum);
     pthread_t *pTid = (pthread_t*)malloc(sizeof(pthread_t) * iThreadNum);
     for (int i = ; i < iThreadNum; ++i)
     {
         pthread_create(&pTid[i], NULL, func, NULL);
     }

     for (int i = ; i < iThreadNum; ++i)
     {
         pthread_join(pTid[i], NULL);
     }

     return ;
 }

tcpCli

 /*
  * gcc -o tcpSvr ./tcpSvr.c
  */
 #include <unistd.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <arpa/inet.h>
 #include <netinet/in.h>
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
 #include <pthread.h>

 const int PORT = ;

 int main(int argc, char **argv)
 {
     int fd = socket(AF_INET, SOCK_STREAM, );
     if (fd == -)
     {
         perror("socket");
         return errno;
     }

     printf("Port %d\n", PORT);
     struct sockaddr_in addr;
     memset(&addr, , sizeof(addr));
     addr.sin_family = AF_INET;
     addr.sin_addr.s_addr = INADDR_ANY;
     addr.sin_port = htons(PORT);

     if (- == bind(fd, (struct sockaddr*)&addr, sizeof(addr)))
     {
         perror("bind");
         return errno;
     }

     if (- == listen(fd, ))
     {
         perror("listen");
         return errno;
     }

     struct sockaddr_in cli_addr;
     socklen_t cli_addr_len = sizeof(cli_addr);
     sleep();

     int client = accept(fd, (struct sockaddr*)&cli_addr, &cli_addr_len);
     if (client < )
     {
         perror("accept");
         return errno;
     }

     char buf[];
     int iCount = ;
     int iZero = ;
     while()
     {
         memset(buf, , );
         int iRet = recv(client, buf, , );
         printf("Recv package count[%d]\t", iCount);
         printf("recv content [%s]\n", buf);
         iRet = send(client, buf, iRet, );

         iRet = iRet/iZero;
     }
     close(fd);

     return ;
 }

tcpSvr

实验结果：

执行：tcpCli 15 的结果

这是使用grep过滤了tcpSvr的显示结果：

这是使用grep过滤了tcpCli的显示结果：

这是过了一段时间后，tcpCli输出的结果：

TCP状态转移图：

然后根据这些结果以及TCP状态转移图，可以得出如下结论：

在server端处在ESTABLISHED状态的有6个连接，有4个处在SYN_RECV状态（这四个连接过一段时间会关闭）

但是在client端，15个连接全部处在ESTABLISHED状态，并且此次修改了tcpCli的代码，在connect之后打印“Connect Succ”显示15个连接都成功了。

安装TCP状态转移图，svr端收到TCK就应该转移到ESTABLISHED状态了，根据tcpdump抓包也看到回的ACK包，但是为什么netstat看不到这些连接、或者看到的SYN_RECV状态呢？

到底在tcp未处理连接请求达到backlog值之后，对于新到来的连接请求，tcp协议栈做什么处理呢？

根据tcpdump抓包数据分析：

无状态的端口对应的包：

svr端在不停的发送第二次握手的包（syn, ack=syn+1)，这就意味着svr端未收到cli发的第三次握手的包（ack包），但是tcpdump抓包发现，每次svr发送过（syn,ack=syn+1)后，cli都回包了。这么分析只有一个原因，虽然tcp收到了ack包，但是没有接受、或者说抛弃了。于是tcp协议层就认为没有收到ack，于是发生重传。

SYN_RECV状态对应的包：

情况同上面类似，但是为什么它们的状态时SYN_RECV呢？

ESTABLISHED状态对应的包：

这就是正常的三次握手的包了。

2017-03-23 更新：

经过知乎上大牛的指点，关于服务端是SYN_RECV状态，而客户端是ESTABLISHED状态的疑问，有了答案，参考：tcp/dccp: drop SYN packets if accept queue is full

这段解释的意思就是，当服务端未处理连接队列满的时候，它就会丢掉client端发送的三次握手中的最后一个ACK包，这就会导致，client端以为自己已经建立连接了，但是实际在server端没有连接，同时也解释了tcpdump抓包看到的，为什么server一直不停的发送三次握手的第二次数据包（SYN+ACK）。

另外，关于这种类似的问题，就像知乎浅墨说的，策略在不停的改变，不要听信网上别人的说法，自己动手试一下就可以了。