TCP超时重传定时器梳理

最新推荐文章于 2024-08-14 14:18:53 发布
最新推荐文章于 2024-08-14 14:18:53 发布
阅读量5k 收藏 10
点赞数 1
分类专栏： TCP/IP协议 文章标签： 超时重传定时器 TCP-IP linux 内核
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010039418/article/details/78234570
版权

注：本文分析基于3.10.107内核版本

简介

超时重传定时器是TCP连接可靠性的重要保证，其工作原理为TCP连接在发送某一个数据报文或者SYN报文后，该连接就会启动一个定时器，在规定时间内如果没有收到对端回复的ACK报文，那么定时器超时处理函数就重新发送数据，直到发送成功或者达到最大重传次数而上报错误为止。

定时器类型

一个TCP连接有多个定时器来保证TCP连接的可靠性及其传输效率。在include/net/inet_connection_sock.h中定义了以下几个定时器

#define ICSK_TIME_RETRANS   1   /* Retransmit timer */
#define ICSK_TIME_DACK      2   /* Delayed ack timer */
#define ICSK_TIME_PROBE0    3   /* Zero window probe timer */
#define ICSK_TIME_EARLY_RETRANS 4   /* Early retransmit timer */
#define ICSK_TIME_LOSS_PROBE    5   /* Tail loss probe timer */

上面五个定时器分别为：超时重传定时器、ACK延迟定时器、零窗口探测定时器、ER延迟定时器、尾部丢失探测定时器。
另外还有保活定时器、FIN_WAIT2定时器、TIME_WAIT定时器、SYNACK定时器。

但是在内核中并没有为每个定时器提供一个实例(timer_list)，有些定时器共用一个实例，目前内核里有4个实例:

icsk->icsk_retransmit_timer：超时重传定时器、零窗口探测定时器、ER延迟定时器、尾部丢失探测定时器。
icsk->icsk_delack_timer：ACK延迟定时器。
sk->sk_timer：保活定时器，SYNACK定时器，FIN_WAIT2定时器。
death_row->tw_timer：TIME_WAIT定时器。

定时器的创建

这里我们主要关注超时重传定时器的创建流程，如下：
tcp_v4_init_sock
—->tcp_init_sock
——–>tcp_init_xmit_timers
————>inet_csk_init_xmit_timers
在连接初始化时，除了会创建超时重传定时器，ACK延迟定时器和保活定时器也会被一起创建。

void tcp_init_xmit_timers(struct sock *sk)
{
    inet_csk_init_xmit_timers(sk, &tcp_write_timer, &tcp_delack_timer, &tcp_keepalive_timer);
}

/*
 * Using different timers for retransmit, delayed acks and probes
 * We may wish use just one timer maintaining a list of expire jiffies
 * to optimize.
 */
void inet_csk_init_xmit_timers(struct sock *sk,
                   void (*retransmit_handler)(unsigned long),
                   void (*delack_handler)(unsigned long),
                   void (*keepalive_handler)(unsigned long))
{
    struct inet_connection_sock *icsk = inet_csk(sk);

    setup_timer(&icsk->icsk_retransmit_timer, retransmit_handler,
            (unsigned long)sk);
    setup_timer(&icsk->icsk_delack_timer, delack_handler,
            (unsigned long)sk);
    setup_timer(&sk->sk_timer, keepalive_handler, (unsigned long)sk);
    icsk->icsk_pending = icsk->icsk_ack.pending = 0;
}

定时器的激活

超时重传定时器的激活有很多种场景，目前个人有接触主要有以下两种：
1、TCP建链发送SYN报文时；
2、发送数据时，每收到对端的ACK报文，也会reset定时器。
我们从发送SYN报文流程里看：

/* Build a SYN and send it off. */
int tcp_connect(struct sock *sk)
{
    ...
    /* 这里是初始化传输控制块中与连接相关的成员
       其中就包括对重传超时时间RTO的初始化，对于
       SYN报文时1s，不同内核版本该值会不一样，在
       内核版本3.0.101(SUSE11SP3)上该值是3s。
    */
    tcp_connect_init(sk);
    ...

    /* Timer for repeating the SYN until an answer. 
       这里便是激活超时重传定时器了，其中TCP_RTO_MAX的值为120s。
    */
    inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
                  inet_csk(sk)->icsk_rto, TCP_RTO_MAX);
    return 0;
}

inet_csk_reset_xmit_timer函数里不仅负责对超时重传定时器进行重置，还负责其他4个定时器的激活。

/*
 *  Reset the retransmission timer
 */
static inline void inet_csk_reset_xmit_timer(struct sock *sk, const int what,
                         unsigned long when,
                         const unsigned long max_when)
{
    struct inet_connection_sock *icsk = inet_csk(sk);

    if (when > max_when) {
        when = max_when;
    }

    /* 重传定时器，零窗口探测定时器，ER定时器，PTO定时器以及迟定ACK定时器都通过该接口激活 */
    if (what == ICSK_TIME_RETRANS || what == ICSK_TIME_PROBE0 ||
        what == ICSK_TIME_EARLY_RETRANS || what ==  ICSK_TIME_LOSS_PROBE) {
        icsk->icsk_pending = what;
        icsk->icsk_timeout = jiffies + when;//报文超时时间
        sk_reset_timer(sk, &icsk->icsk_retransmit_timer, icsk->icsk_timeout);//重置定时器
    } else if (what == ICSK_TIME_DACK) {
        icsk->icsk_ack.pending |= ICSK_ACK_TIMER;
        icsk->icsk_ack.timeout = jiffies + when;
        sk_reset_timer(sk, &icsk->icsk_delack_timer, icsk->icsk_ack.timeout);
    }
}

超时处理函数

从上面定时器创建流程中我们知道，超时重传定时器的超时处理函数是tcp_write_timer()。

static void tcp_write_timer(unsigned long data)
{
    struct sock *sk = (struct sock *)data;

    bh_lock_sock(sk);
    if (!sock_owned_by_user(sk)) {// 什么情况下会被用户占用呢，不太理解，有知道的请赐教
        tcp_write_timer_handler(sk);
    } else {// 设置延迟标志，之后再处理
        /* deleguate our work to tcp_release_cb() */
        if (!test_and_set_bit(TCP_WRITE_TIMER_DEFERRED, &tcp_sk(sk)->tsq_flags))
            sock_hold(sk);
    }
    bh_unlock_sock(sk);
    sock_put(sk);
}

tcp_write_timer_handler()函数中根据触发的定时器类型，采取对应处理，如果是超时重传定时器会进入tcp_retransmit_timer()函数里处理。

/*
 *  The TCP retransmit timer.
 */

void tcp_retransmit_timer(struct sock *sk)
{
    struct tcp_sock *tp = tcp_sk(sk);
    struct inet_connection_sock *icsk = inet_csk(sk);

    if (tp->fastopen_rsk) {//fast open，让TCP三次握手过程也能交换数据，没太研究，略过
        WARN_ON_ONCE(sk->sk_state != TCP_SYN_RECV &&
                 sk->sk_state != TCP_FIN_WAIT1);
        tcp_fastopen_synack_timer(sk);
        /* Before we receive ACK to our SYN-ACK don't retransmit
         * anything else (e.g., data or FIN segments).
         */
        return;
    }
    //packets_out表示发送出去尚未收到对端确认的数据包，如果没有，超时就没意义，返回
    if (!tp->packets_out)
        goto out;

    WARN_ON(tcp_write_queue_empty(sk));

    tp->tlp_high_seq = 0;

    //收到对端窗口为0，sk状态不为SOCK_DEAD，同时也不处于TCP三次握手期间，也就是在established状态下出现了拥塞
    if (!tp->snd_wnd && !sock_flag(sk, SOCK_DEAD) &&
        !((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))) {
        struct inet_sock *inet = inet_sk(sk);
        if (sk->sk_family == AF_INET) {
            LIMIT_NETDEBUG(KERN_DEBUG pr_fmt("Peer %pI4:%u/%u unexpectedly shrunk window %u:%u (repaired)\n"),
                       &inet->inet_daddr,
                       ntohs(inet->inet_dport), inet->inet_num,
                       tp->snd_una, tp->snd_nxt);
        }
        // 距离上次接收到ACK的时间超过TCP_RTO_MAX，120s，就认为有错误发生了
        if (tcp_time_stamp - tp->rcv_tstamp > TCP_RTO_MAX) {
            tcp_write_err(sk);//最终通过ICMP报文上报错误到应用层
            goto out;
        }
        //报文丢失，要进行拥塞处理和标识丢失数据段
        tcp_enter_loss(sk, 0);
        /* 重传发送队列里的第一个数据段 */
        tcp_retransmit_skb(sk, tcp_write_queue_head(sk));
        __sk_dst_reset(sk);//刷路由
        goto out_reset_timer;
    }

    // TCP三次握手期间的定时器超时会走到下面的流程，判断连接是否超时
    if (tcp_write_timeout(sk))
        goto out;

    if (icsk->icsk_retransmits == 0) {//第一次进入超时重传流程
        int mib_idx;

        if (icsk->icsk_ca_state == TCP_CA_Recovery) {
            if (tcp_is_sack(tp))
                mib_idx = LINUX_MIB_TCPSACKRECOVERYFAIL;
            else
                mib_idx = LINUX_MIB_TCPRENORECOVERYFAIL;
        } else if (icsk->icsk_ca_state == TCP_CA_Loss) {
            mib_idx = LINUX_MIB_TCPLOSSFAILURES;
        } else if ((icsk->icsk_ca_state == TCP_CA_Disorder) ||
               tp->sacked_out) {
            if (tcp_is_sack(tp))
                mib_idx = LINUX_MIB_TCPSACKFAILURES;
            else
                mib_idx = LINUX_MIB_TCPRENOFAILURES;
        } else {
            mib_idx = LINUX_MIB_TCPTIMEOUTS;
        }
        NET_INC_STATS_BH(sock_net(sk), mib_idx);
    }

    tcp_enter_loss(sk, 0);

    /* 重传发送队列里的第一个数据段 */
    if (tcp_retransmit_skb(sk, tcp_write_queue_head(sk)) > 0) {
        /* Retransmission failed because of local congestion,
         * do not backoff. 尚未仔细研究什么情况会出现返回值大于零
         */
        if (!icsk->icsk_retransmits)
            icsk->icsk_retransmits = 1;
        inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
                      min(icsk->icsk_rto, TCP_RESOURCE_PROBE_INTERVAL),
                      TCP_RTO_MAX);
        goto out;
    }

    icsk->icsk_backoff++;//增加指数退避次数
    icsk->icsk_retransmits++;//增加重传次数

out_reset_timer:
    if (sk->sk_state == TCP_ESTABLISHED &&
        (tp->thin_lto || sysctl_tcp_thin_linear_timeouts) &&
        tcp_stream_is_thin(tp) &&
        icsk->icsk_retransmits <= TCP_THIN_LINEAR_RETRIES) {
        icsk->icsk_backoff = 0;
        icsk->icsk_rto = min(__tcp_set_rto(tp), TCP_RTO_MAX);
    } else {
        /* Use normal (exponential) backoff */
        icsk->icsk_rto = min(icsk->icsk_rto << 1, TCP_RTO_MAX);//正常指数退避
    }
    inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, icsk->icsk_rto, TCP_RTO_MAX);//重置定时器
    //当距离原始包发送6.2s后还未收到应答包时，就要刷新路由
    if (retransmits_timed_out(sk, sysctl_tcp_retries1 + 1, 0, 0))
        __sk_dst_reset(sk);//刷路由

out:;
}

重传到一定次数后就该返回超时了，在tcp_write_timeout里判断连接是否超时。

/* A write timeout has occurred. Process the after effects. */
static int tcp_write_timeout(struct sock *sk)
{
    struct inet_connection_sock *icsk = inet_csk(sk);
    int retry_until;
    bool do_reset, syn_set = false;

    if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {//TCP三次握手期间
        if (icsk->icsk_retransmits)
            dst_negative_advice(sk);//之前重传过，那就要更新路由缓存了
        // 获取重传次数，对于SYN报文系统默认5次，即内核参数sysctl_tcp_syn_retries，
        // 用户可以通过setsockopt的TCP_SYNCNT选项设置该参数，也可以通过修改/proc里面的内核参数
        retry_until = icsk->icsk_syn_retries ? : sysctl_tcp_syn_retries;
        syn_set = true;//设置syn标识
    } else {
        // tcp_retries1默认为3，当数据报文重传次数超过此值时，也就是距离原始包发送3s后还未收到ACK报文
        // 表示可能遇到了黑洞，需要进行PMTU检测，并刷新路由
        if (retransmits_timed_out(sk, sysctl_tcp_retries1, 0, 0)) {
            /* Black hole detection */
            tcp_mtu_probing(icsk, sk);

            dst_negative_advice(sk);
        }

        retry_until = sysctl_tcp_retries2;//数据报文重传次数默认15次
        if (sock_flag(sk, SOCK_DEAD)) {
            const int alive = (icsk->icsk_rto < TCP_RTO_MAX);

            retry_until = tcp_orphan_retries(sk, alive);
            do_reset = alive ||
                !retransmits_timed_out(sk, retry_until, 0, 0);

            if (tcp_out_of_resources(sk, do_reset))
                return 1;
        }
    }

    //判断连接是否超时
    if (retransmits_timed_out(sk, retry_until,
                  syn_set ? 0 : icsk->icsk_user_timeout, syn_set)) {
        /* Has it gone just too far? */
        tcp_write_err(sk);//最终通过ICMP报文上报错误
        return 1;
    }
    return 0;
}


static bool retransmits_timed_out(struct sock *sk,
                  unsigned int boundary,
                  unsigned int timeout,
                  bool syn_set)
{
    unsigned int linear_backoff_thresh, start_ts;
    //如果是SYN包，则初始超时时间为1s，上面说过不同内核该值可能不一样
    //如果是数据包，则为200ms
    unsigned int rto_base = syn_set ? TCP_TIMEOUT_INIT : TCP_RTO_MIN;

    if (!inet_csk(sk)->icsk_retransmits)//之前没有重传，何来超时
        return false;

    //在tcp_connect()函数中会对retrans_stamp进行赋值，因此超时时间计算使用的是原始包发送的时间戳来计算
    if (unlikely(!tcp_sk(sk)->retrans_stamp))
        start_ts = TCP_SKB_CB(tcp_write_queue_head(sk))->when;
    else
        start_ts = tcp_sk(sk)->retrans_stamp;

    //有两种情况：对于SYN包，timeout始终设置为0，因为在三次握手期间TCP_USER_TIMEOUT是无效的
    //对于非SYN包，如果用户没有设置TCP_USER_TIMEOUT，那timeout也为0
    if (likely(timeout == 0)) {
        //对于SYN包，rto_base为1s，可求得最大指数退避次数为log2(120)，向上取整为7次
        //SYN包的boundary为5次
        linear_backoff_thresh = ilog2(TCP_RTO_MAX/rto_base);

        if (boundary <= linear_backoff_thresh)
            //正常情况都是按这个计算超时时间，对于SYN报文超时时间是63s
            timeout = ((2 << boundary) - 1) * rto_base;
        else
            timeout = ((2 << linear_backoff_thresh) - 1) * rto_base +
                (boundary - linear_backoff_thresh) * TCP_RTO_MAX;
    }
    return (tcp_time_stamp - start_ts) >= timeout;
}

也就是说，对于SYN报文，需要重传5次，历时63s才能最终返回超时。

这个可以通过一个实验来证实。在A、B两台服务器上，A向B发起连接，B上把防火墙默认规则设置为DROP，然后用tcpdump抓包，就可以看到A一共向B发送了6次SYN报文，然后A发起的连接才返回timeout。

参考资料:
1、http://blog.csdn.net/zhangskd/article/details/35281345

Blue summer
关注
专栏目录
【C++/嵌入式梳理】二、24.TCP三次握手四次挥手 | TCP可靠性
Hi
07-14 1302
【C++/嵌入式笔试面试八股】二、24.TCP三次握手四次挥手 | TCP可靠性
一文详解 TCP与UDP协议：深度解析与场景应用
bjxiaxueliang的CODING技术小馆
05-19 3518
本文要介绍的TCP与UDP协议是TCP/IP 协议簇的核心成员，而TCP/IP协议簇是 Internet 的基础，也是一系列网络协议的总称。如：TCP、UDP、IP、FTP、HTTP、ICMP、SMTP等都属于TCP/IP协议族内的协议。这些协议在计算机网络中自上而下被划分为四层：应用层、传输层、网络层和链路层。
TCP重传定时器
a364572的专栏
10-23 1752
//本文主要介绍linux内核中TCP的重传定时器机制:用到的源代码是2.6.38 //一个tcp连接中，如果一方过了rto时间内都没收到对方的ACK，会触发重传并调用tcp_write_timer定时器处理函数 //其中RTO表示重传时间，RTO是动态计算的，需要考虑到当前的重传次数。 //tcp_write_timer调用tcp_retransmit_timer重传处理函数，后者会调用t
搞懂TCP/IP协议看这篇就够了
最新发布
Ghost1898688的博客
08-14 1361
TCP是面向连接的、可靠的、有序的、无丢失无重复的数据传输协议，面向字节流。提高TCP传输性能是一个重要的话题，今天我们从TCP三次握手、TCP四次挥手和数据发送三个方面来进行优化。
TCP的重传机制(转)
seven407的专栏
03-22 1612
与数据链路层的ARQ协议相类似，TCP使用超时重发的重传机制。即：TCP每发送一个报文段，就对此报文段设置一个超时重传计时器。此计时器设置的超时重传时间RTO（Retransmission Time－Out）应当略大于TCP报文段的平均往返时延RTT，一般可取RTO＝2RTT。但是，也可以根据具体情况人为调整RTO的值，例如可以设置此超时重传时间RTO＝90秒。当超过了规定的超时重传时间还未收到对此TCP报文段的预期确认信息，则必须重新传输此TCP报文段。注意，TCP在使用滑动窗口时，可以等效为数据链路
TCP 四种定时器（重传定时器，坚持计时器，保活定时器，时间等待计时器）
08-31
主要介绍了TCP 四种定时器，重传定时器，坚持计时器，保活定时器，时间等待计时器的相关资料,需要的朋友可以参考下
解读TCP 四种定时器
xiaofei0859的专栏
10-12 1万+
一.TCP的四种定时器 TCP使用四种定时器（Timer，也称为“计时器”）： 重传计时器：Retransmission Timer 坚持计时器：Persistent Timer 保活计时器：Keeplive Timer 时间等待计时器：Time_Wait Timer。   （1）重传计时器： 重传定时器：为了控制丢失的报文段或丢弃的报文段，也就是对报文段确认的等待时间
TCP定时器之超时重传定时器
九天小哥的专栏
03-09 5052
每条TCP连接都会维护一个超时重传定时器，该定时器是TCP保证可靠性的一个非常重要的手段，一旦该定时器超时，那么就会重传还未收到ACK的报文。这篇笔记就来看看该定时器相关的代码实现。 1. 相关数据结构 struct inet_connection_sock { ... //icsk_retransmit_timer的超时时刻，jiffies超过该值时定时器超时 unsigned long ...
计算机网络 TCP协议梳理
baiiu
01-07 1269
前言 本文梳理TCP协议 TCP：Transmission Control Protocol ，传输控制协议 TCP的主要特性 面向连接的传输协议 是指应用程序在使用TCP之前，必须先建立TCP传输连接，在传输数据完毕后，必须释放已建立的TCP传输连接。 仅支持单播传输 每条TCP传输连接只能有两个端点(socket)，只能进行点对点的数据传输，不支持多播和广播的传输方式。 提供可靠的交付服务 TCP可以无差错、不丢失、不重复，且按时序达到对端。 传输单位为数据段 TCP仍采用了传统的"数据段"作为数据传
7 TCP拥塞控制整体流程梳理
qq_27420299的博客
07-07 802
上一篇主要通过RFC-2581协议讲述了拥塞控制的四个控制算法，这一篇呢，主要是对整个TCP传输做一个梳理，从正常情况到异常情况依次进行分析。（RFC-2581 协议描述：https://mp.csdn.net/mdeditor/90523999#） 0.基本参数 IW ：初始拥塞窗口，根据2581，IW <= 2*SMSS LW：重传定时器检测到丢包后的当前拥塞窗口 Cwnd：拥塞窗口 R...
6.RFC-2581协议(慢启动+拥塞避免+快速重传+快速恢复)
qq_27420299的博客
07-06 1495
RFC-2581协议
TCP的定时器系列 — 超时重传定时器
热门推荐
zhangskd的专栏
03-30 2万+
主要内容：TCP定时器开篇，超时重传定时器、ER延迟定时器、PTO定时器的实现。 内核版本：3.15.2 我的博客：http://blog.csdn.net/zhangskd   Q：一条TCP连接会使用多少个定时器呢？ A：目前的答案是9个： 超时重传定时器，持续定时器，ER延迟定时器，PTO定时器，ACK延迟定时器， SYNACK定时器，保活定时器，FIN_WAIT2定时器，CL
TCP的四种定时器简单记录
weixin_34357928的博客
03-06 141
TCP管理的4个不同的定时器： 1.重传定时器：用于当希望收到另一端的确认。 2.坚持定时器：使窗口大小信息保持不断流动。 3.保活定时器：检测TCP空闲连接的另一端何时崩溃或重启。 4.2MSL定时器：测量一个连接处于TIME_WAIT状态的时间。MSL(报文段最大生存时间) 重传定时器： 规定：第一次发送后所设置的超时时间为1.5秒，之后为3、6、12、24、48、多个64秒...
TCP 定时器
m0_57015193的博客
08-10 245
TCP 内部维护了如下七种定时器： 建立连接定时器：主要用于 TCP 三次握手时，发送完 SYN 包后启动定时器，如果 3S 内没有收到 ACK，重发 SYN 包，直到达到最大重传此时 重传定时器：主要用于 TCP 超时重传，TCP 发送报文时创建重传计时器，指定时间内返回则撤销定时器，否则超时重发并复位定时器 坚持定时器：TCP 通过让接收方指明窗口大小实现流量控制，当接收方窗口已满时告诉发送方暂时不要发送，直到接收方窗口不满时返回 ACK 报文告诉发送方可以发送数据。为了防止该 ACK 报文丢失，双方
TCP定时器
weixin_35140291的博客
07-17 299
TCP使用四种定时器（Timer，也称为“计时器”）： 重传计时器：Retransmission Timer 坚持计时器：Persistent Timer 保活计时器：Keeplive Timer 时间等待计时器：Time_Wait Timer。重传计时器 当TCP发送报文段时，就创建该特定报文段的重传计时器。 若在计时器截止时间到(通常60秒)之前收到了对此特定报文段的确认，则撤销
【网络协议】TCP中的四大定时器
兰亭风雨的专栏
06-20 8064
前言 对于每个TCP连接，TCP一般要管理4个不同的定时器：重传定时器、坚持定时器、保活定时器、2MSL定时器。 重传定时器 很明显重传定时器是用来计算TCP报文段的超时重传时间的（至于超时重传时间的确定，这里涉及到一大堆的算法，书上有说，我这里不细谈了）。每发送一个报文段就会启动重传定时器，如果在定时器时间到后还没收到对该报文段的确认，就重传该报文段，并将重传定时器复位，重新计算；如果在规定时间内收到了对该报文段的确认，则撤销该报文段的重传定时器。 坚持定时器
TCP的四种定时器
ftzchina的博客
07-15 2994
TCP提供可靠的端到端数据传输，保证端到端的方法之一就是确认从另一端收到的数据。但数据和ACK在传输的过程中有可能会丢失。TCP通过在发送时设置一个定时器来解决这种问题。 对于每个连接，TCP管理4个不同的定时器。 1，重传定时器：适用于希望收到另一端的确认ACK 2，坚持定时器：使窗口大小信息保持不断流动，即使另一端关闭了其接收窗口 3，保活定时器：可检测一个空闲连接的另一端何时崩溃或重启 4，2M...
tcp中的常见定时器
weixin_30907523的博客
06-28 104
(1)超时重传定时器tcp的靠谱特性，通过确认机制，保证每一个包都被对方收到，那么什么时候需要重传呢？就是靠这个超时重传定时器，每次发送报文前都启动这个定时器，如果定时器超时之前收到了应答则关闭定时器，如果没收到就重发该报文，并重置定时器。 (2)建连定时器和重传定时器类似，发送syn时，为了防止被丢弃，一段时间不回复ack也会重传。 (3)TIME_WAIT(2MSL)...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值