☰

已绑定的TCP本地套接字地址关闭后多久不可用？

tag-icon • tag-icon linux tcp system-calls socket timeout
已绑定的TCP本地套接字地址关闭后多久不可用？

在 Linux 上（我的实时服务器在 RHEL 5.5 上 - 下面的 LXR 链接是其中的内核版本），man 7 ip说：

已绑定的 TCP 本地套接字地址在关闭后一段时间内不可用，除非已设置 SO_REUSEADDR 标志。

我没有使用SO_REUSEADDR. “一段时间”有多长？我怎样才能知道它有多长，以及如何更改它？

我一直在谷歌上搜索这个问题，并找到了一些信息，但这些信息都没有真正从应用程序程序员的角度解释这一点。以机智：

  • TCP_TIMEWAIT_LENinnet/tcp.h是“要等待多长时间才能销毁TIME-WAIT状态”，固定为“大约60秒”
  • /proc/sys/net/ipv4/tcp_fin_timeout是“如果我们这边关闭了套接字，则将套接字保持在 FIN-WAIT-2 状态的时间”，并且“默认值为 60 秒”

我遇到的困难在于弥合 TCP 生命周期的内核模型和程序员的端口不可用模型之间的差距，即理解这些状态如何与“某个时间”相关。

答案1

我相信套接字对程序不可用的想法是允许任何仍在传输中的 TCP 数据段到达，并被内核丢弃。也就是说，应用程序可能会调用close(2)套接字，但路由延迟或控制数据包的事故或可能允许 TCP 连接的另一端暂时发送数据。应用程序已表明它不再希望处理 TCP 数据段，因此内核应该在它们进入时将其丢弃。

我用 C 编写了一个小程序，您可以编译并使用它来查看超时时间：

#include <stdio.h>        /* fprintf() */
#include <string.h>       /* strerror() */
#include <errno.h>        /* errno */
#include <stdlib.h>       /* strtol() */
#include <signal.h>       /* signal() */
#include <sys/time.h>     /* struct timeval */
#include <unistd.h>       /* read(), write(), close(), gettimeofday() */
#include <sys/types.h>    /* socket() */
#include <sys/socket.h>   /* socket-related stuff */
#include <netinet/in.h>
#include <arpa/inet.h>    /* inet_ntoa() */
float elapsed_time(struct timeval before, struct timeval after);
int
main(int ac, char **av)
{
        int opt;
        int listen_fd = -1;
        unsigned short port = 0;
        struct sockaddr_in  serv_addr;
        struct timeval before_bind;
        struct timeval after_bind;

        while (-1 != (opt = getopt(ac, av, "p:"))) {
                switch (opt) {
                case 'p':
                        port = (unsigned short)atoi(optarg);
                        break;
                }
        }

        if (0 == port) {
                fprintf(stderr, "Need a port to listen on\n");
                return 2;
        }

        if (0 > (listen_fd = socket(AF_INET, SOCK_STREAM, 0))) {
                fprintf(stderr, "Opening socket: %s\n", strerror(errno));
                return 1;
        }

        memset(&serv_addr, '\0', sizeof(serv_addr));
        serv_addr.sin_family      = AF_INET;
        serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
        serv_addr.sin_port        = htons(port);

        gettimeofday(&before_bind, NULL);
        while (0 > bind(listen_fd, (struct sockaddr *)&serv_addr, sizeof(serv_addr))) {
                fprintf(stderr, "binding socket to port %d: %s\n",
                        ntohs(serv_addr.sin_port),
                        strerror(errno));

                sleep(1);
        }
        gettimeofday(&after_bind, NULL);
        printf("bind took %.5f seconds\n", elapsed_time(before_bind, after_bind));

        printf("# Listening on port %d\n", ntohs(serv_addr.sin_port));
        if (0 > listen(listen_fd, 100)) {
                fprintf(stderr, "listen() on fd %d: %s\n",
                        listen_fd,
                        strerror(errno));
                return 1;
        }

        {
                struct sockaddr_in  cli_addr;
                struct timeval before;
                int newfd;
                socklen_t clilen;

                clilen = sizeof(cli_addr);

                if (0 > (newfd = accept(listen_fd, (struct sockaddr *)&cli_addr, &clilen))) {
                        fprintf(stderr, "accept() on fd %d: %s\n", listen_fd, strerror(errno));
                        exit(2);
                }
                gettimeofday(&before, NULL);
                printf("At %ld.%06ld\tconnected to: %s\n",
                        before.tv_sec, before.tv_usec,
                        inet_ntoa(cli_addr.sin_addr)
                );
                fflush(stdout);

                while (close(newfd) == EINTR) ;
        }

        if (0 > close(listen_fd))
                fprintf(stderr, "Closing socket: %s\n", strerror(errno));

        return 0;
}
float
elapsed_time(struct timeval before, struct timeval after)
{
        float r = 0.0;

        if (before.tv_usec > after.tv_usec) {
                after.tv_usec += 1000000;
                --after.tv_sec;
        }

        r = (float)(after.tv_sec - before.tv_sec)
                + (1.0E-6)*(float)(after.tv_usec - before.tv_usec);

        return r;
}

我在 3 台不同的机器上尝试了这个程序，当内核拒绝允许非 root 用户重新打开套接字时，我得到了 55 到 59 秒之间的可变时间。我将上面的代码编译为名为“opener”的可执行文件，并按如下方式运行：

./opener -p 7896; ./opener -p 7896

我打开了另一个窗口并执行了以下操作：

telnet otherhost 7896

这会导致“opener”的第一个实例接受连接，然后关闭它。 “opener”的第二个实例bind(2)每秒尝试访问 TCP 端口 7896。 “opener”报告有 55 到 59 秒的延迟。

谷歌搜索后，我发现人们建议这样做：

echo 30 > /proc/sys/net/ipv4/tcp_fin_timeout

以减少该间隔。这对我不起作用。在我可以访问的 4 台 Linux 机器中，两台有 30 个，两台有 60 个。我还将该值设置为低至 10。与“opener”程序没有区别。

这样做：

echo 1 > /proc/sys/net/ipv4/tcp_tw_recycle

确实改变了事情。第二个“开启者”只花了大约 3 秒就获得了新的套接字。

相关内容