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 = 7766;

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

    struct sockaddr_in addr;
    memset(&addr, 0, 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
", iWBufSize);

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

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

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

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

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

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

    return 0;
}

/*
 * 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 = 7766;

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

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

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

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

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

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

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

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

    return 0;
}

实验结果：

执行：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）。

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