Quanto tempo é um endereço de socket local TCP que foi ligado indisponível após o fechamento?

12

No Linux (meus servidores ativos estão no RHEL 5.5 - os links LXR abaixo estão na versão do kernel), man 7 ip diz:

A TCP local socket address that has been bound is unavailable for some time after closing, unless the SO_REUSEADDR flag has been set.

Eu não estou usando SO_REUSEADDR . Quanto tempo é "algum tempo"? Como posso descobrir quanto tempo é e como posso mudá-lo?

Eu pesquisei isso e encontrei alguns pedaços de informação, nenhum dos quais realmente explica isso da perspectiva de um programador de aplicativos. A saber:

Onde eu tropeço é colmatar a lacuna entre o modelo do kernel do ciclo de vida do TCP, e o modelo de portas do programador não está disponível, isto é, entender como esses estados se relacionam com o "algum tempo".

    
por Tom Anderson 22.07.2011 / 13:32

1 resposta

12

Eu acredito que a idéia do socket estar indisponível para um programa é permitir que qualquer segmento de dados TCP ainda em trânsito chegue, e seja descartado pelo kernel. Ou seja, é possível que um aplicativo chame close(2) em um soquete, mas atrasos de roteamento ou percalços para controlar pacotes ou o que permite que o outro lado de uma conexão TCP envie dados por algum tempo. O aplicativo indicou que não deseja mais lidar com segmentos de dados TCP, portanto, o kernel deve descartá-los apenas quando eles chegarem.

Eu cortei um pequeno programa em C que você pode compilar e usar para ver quanto tempo o tempo limite é:

#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, '
./opener -p 7896; ./opener -p 7896
', 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; }

Eu tentei este programa em 3 máquinas diferentes, e eu recebo um tempo variável, entre 55 e 59 segundos, quando o kernel se recusa a permitir que um usuário não-root reabra um socket. Eu compilei o código acima para um executável chamado "opener", e corri assim:

telnet otherhost 7896

Eu abri outra janela e fiz isso:

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

Isso faz com que a primeira instância de "opener" aceite uma conexão e feche-a. A segunda instância de "opener" tenta bind(2) para a porta TCP 7896 a cada segundo. "opener" reporta 55 a 59 segundos de atraso.

Pesquisando, acho que as pessoas recomendam fazer isso:

echo 1 > tcp_tw_recycle

para reduzir esse intervalo. Não funcionou para mim. Das 4 máquinas linux que eu tinha acesso, duas tinham 30 e duas tinham 60. Eu também defini esse valor tão baixo quanto 10. Nenhuma diferença para o programa "opener".

Fazendo isso:

#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, '
./opener -p 7896; ./opener -p 7896
', 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; }

mudou as coisas. O segundo "abridor" levou apenas cerca de 3 segundos para obter seu novo soquete.

    
por 22.07.2011 / 15:30