(3) linux 3.x

http://blog.csdn.net/zhangskd/article/details/47380761

主要内容：客户端接收SYNACK、发送ACK，完成连接的建立。

内核版本：3.15.2

我的博客：http://blog.csdn.net/zhangskd

接收入口

tcp_v4_rcv

    |--> tcp_v4_do_rcv

               |-> tcp_rcv_state_process

                         |-> tcp_rcv_synsent_state_process

1. 状态为ESTABLISHED时，用tcp_rcv_established()接收处理。

2. 状态为LISTEN时，说明这个sock处于监听状态，用于被动打开的接收处理，包括SYN和ACK。

3. 当状态不为ESTABLISHED或TIME_WAIT时，用tcp_rcv_state_process()处理。

客户端主动建立连接时，发送SYN段后，连接的状态变为SYN_SENT。

此时如果收到SYNACK段，处理函数为tcp_rcv_state_process()。

int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
{
    struct sock *rsk;

#ifdef CONFIG_TCP_MD5SIG
    /* We really want to reject the packet as early as possible if :
     * We're expecting an MD5'd packet and this is no MD5 tcp option.
     * There is an MD5 option and we're not expecting one.
     */
    if (tcp_v4_inbound_md5_hash(sk, skb))
        goto discard;
#endif

    /* 当状态为ESTABLISHED时，用tcp_rcv_established()接收处理 */
    if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
        struct dst_entry *dst = sk->sk_rx_dst;
        sock_rps_save_rxhash(sk, skb);

        if (dst) {
            if (inet_sk(sk)->rx_dst_ifindex != skb->skb_iif || dst->ops->check(dst, 0) == NULL) {
                dst_release(dst);
                sk->sk_rx_dst = NULL;
            }
        }

        /* 连接已建立时的处理路径 */
        tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len);
        return 0;
    }

    /* 检查报文长度、报文校验和 */
    if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
        goto csum_err;

    /* 如果这个sock处于监听状态，被动打开时的处理，包括收到SYN或ACK */
    if (sk->sk_state == TCP_LISTEN) {
        /* 返回值：
         * NULL，错误
         * nsk == sk，接收到SYN
         * nsk != sk，接收到ACK
         */
        struct sock *nsk = tcp_v4_hnd_req(sk, skb);

        if (! nsk)
            goto discard;

        if (nsk != sk) { /* 接收到ACK时 */
            sock_rps_save_rxhash(nsk, skb);

            if (tcp_child_process(sk, nsk, skb)) { /* 处理新的sock */
                rsk = nsk;
                goto reset;
            }
            return 0;
        }
    } else
        sock_rps_save_rx(sk, skb);

    /* 处理除了ESTABLISHED和TIME_WAIT之外的所有状态，包括SYN_SENT状态 */
    if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len)) {
        rsk = sk;
        goto reset;
    }
    return 0;

reset:
    tcp_v4_send_reset(rsk, skb); /* 发送被动的RST包 */

discard:
    kfree_skb(skb);
    return 0;

csum_err:
    TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_CSUMERRORS);
    TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
    goto discard;
}

连接状态不为ESTABLISHED或TIME_WAIT时的处理函数为tcp_rcv_state_process()。

/* This function implements the receiving procedure of RFC 793 for
 * all states except ESTABLISHED and TIME_WAIT.
 */

int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb, const struct tcphdr *th, unsigned int len)
{
    struct tcp_sock *tp = tcp_sk(sk);
    struct inet_connection_sock *icsk = inet_csk(sk);
    struct request_sock *req;
    int queued = 0;
    bool acceptable;
    u32 synack_stamp;

    tp->rx_opt.saw_tstamp = 0;

    switch (sk->sk_state) {
    ...

    case TCP_SYN_SENT:

        /* 处理SYN_SENT状态，主要做了：
         * 判断SYNACK的合法性，更新连接的信息。
         * 把连接状态置为TCP_ESTABLISHED。
         * 发送ACK，可能立即发送，也可能延迟发送。
         */
        queued = tcp_rcv_synsent_state_process(sk, skb, th, len);

        if (queued >= 0)
            return queued; /* 会导致调用函数发送RST */

        tcp_urg(sk, skb, th); /* 处理紧急数据 */

        /* 发送数据，并检查是否需要扩大发送缓存 */
        tcp_data_snd_check(sk);

        return 0;
    }
    ...
}

SYN_SENT状态处理

tcp_rcv_synsent_state_process()用于SYN_SENT状态的处理，具体又分两种场景。

(1) 接收到SYNACK

一般情况下会收到服务端的SYNACK，处理如下：

检查ack_seq是否合法。

如果使用了时间戳选项，检查回显的时间戳是否合法。

检查TCP的标志位是否合法。

如果SYNACK是合法的，更新sock的各种信息。   

把连接的状态设置为TCP_ESTABLISHED，唤醒调用connect()的进程。

判断是马上发送ACK，还是延迟发送。

(2) 接收到SYN

本端之前发送出一个SYN，现在又接收到了一个SYN，双方同时向对端发起建立连接的请求。

处理如下：

把连接状态置为SYN_RECV。

更新sock的各种信息。

构造和发送SYNACK。

接者对端也会回应SYNACK，之后的处理流程和服务器端接收ACK类似，可参考之前的blog。

当tcp_rcv_synsent_state_process()的返回值大于0时，会导致上层调用函数发送一个被动的RST。 

Q：那么什么情况下此函数的返回值会大于0？

A：收到一个ACK段，但ack_seq的序号不正确，或者回显的时间戳不正确。

static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb,
    const struct tcphdr *th, unsigned int len)
{
    struct inet_connection_sock *icsk = inet_csk(sk);
    struct tcp_sock *tp = tcp_sk(sk);
    struct tcp_fastopen_cookie foc = { .len = -1 };
    int saved_clamp = tp->rx_opt.mss_clamp;

    /* 全面解析skb携带的TCP选项 */
    tcp_parse_options(skb, &tp->rx_opt, 0, &foc);
    if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr)
        tp->rx_opt.rcv_tsecr -= tp->tsoffset; /* timestamp offset */

    /* 如果携带ACK标志，那么有可能是SYNACK */
    if (th->ack) {
        /* rfc793:
         * If the state is SYN-SENT then first check the ACK bit
         *     If the ACK bit is set
         *     If the SEG.ACK <= ISS, or SEG.ACK > SND.NXT, send
         *     a reset (unless the RST bit is set, if so drop the segment
         *     and return)"
         */
        /* 检查ack_seq：snd_una < ack_seq <= snd_nxt。
         * 如果SYN段没有携带数据，那么此时ack_seq应该为本端的ISN + 1。
         */
        if (! after(TCP_SKB_CB(skb)->ack_seq, tp->snd_una) ||
            after(TCP_SKB_CB(skb)->ack_seq, tp->snd_nxt))
            goto reset_and_undo;

        /* 如果使用了时间戳选项，那么回显的时间戳，必须落在
         * 第一次发送SYN段的时间和当前时间之间。
         */
        if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
            !between(tp->rx_opt.rcv_tsecr, tp->retrans_stamp, tcp_time_stamp)) {
            NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSACTIVEREJECTED);
            goto reset_and_undo;
        }

        /* Now ACK is acceptable.
         * If the RST bit is set
         *     If the ACK was acceptable then signal the user "error: connection reset",
         *     drop the segment, enter CLOSED state, delete TCB, and return."
         */
        if (th->rst) { /* 如果携带了RST标志位，那么建立连接失败了：）*/
            tcp_reset(sk);
            goto discard;
        }

        /* RFC793:
         * fifth, if neither of the SYN or RST bits is set then drop the segment and return.
         */
        /* 如果既没有RST也没有SYN标志位，那么直接丢弃这个ACK */
        if (! th->syn)
            goto discard_and_undo;

        /* RFC793:
         * If the SYN bit is on ...
         * are acceptable then ...
         * (ousr SYN has been ACKed), change the connection state to ESTABLISHED...
         */
        /* 收到一个合法的SYNACK了，接下来要完成连接的建立了 */

        /* 如果对端支持ECN，SYNACK只会设置ECE标志。
         * 否则，连接就不支持ECN显式拥塞通知了。
         */
        TCP_ECN_rcv_synack(tp, th);

        /* 记录最近更新发送窗口的ACK序号 */
        tcp_init_wl(tp, TCP_SKB_CB(skb)->seq);

        /* 更新发送窗口，删除发送队列中已被确认的SYN段，并进行时延采样 */
        tcp_ack(sk, skb, FLAG_SLOWPATH);

        /* Ok. it's good. Set up sequence numbers and move to established. */
        tp->rcv_nxt = TCP_SKB_CB(skb)->seq + 1; /* 更新接收窗口的要接收的下一个序号 */
        tp->rcv_wup = TCP_SKB_CB(skb)->seq + 1; /* 更新接收窗口的左端 */

        /* RFC1323: The window in SYN & SYN/ACK segments is never scaled.
         * 更新对端接收窗口的大小。在三次握手时，不使用窗口扩大因子。
         */
        tp->snd_wnd = ntohs(th->window);

        /* 如果连接不支持窗口扩大因子选项 */
        if (! tp->rx_opt.wscale_ok) {
            tp->rx_opt.snd_wscale = tp->rx_opt.rcv_wscale = 0;
            tp->window_clamp = min(tp->window_clamp, 65535U);
        }

        /* 如果连接支持时间戳选项 */
        if (tp->rx_opt.saw_tstamp) {
            tp->rx_opt.tstamp_ok = 1;
            tp->tcp_header_len = sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED;
            tp->advmss -= TCPOLEN_TSTAMP_ALIGNED;
            tcp_store_ts_recent(tp); /* 记录对端的时间戳，作为下次发送的回显值 */
        } else {
            tp->tcp_header_len = sizeof(struct tcphdr);
        }

        /* 使用SACK时，才能考虑是否使用FACK */
        if (tcp_is_sack(tp) && sysctl_tcp_fack)
            tcp_enable_fack(tp);

        tcp_mtu_init(sk); /* TCP的MTU初始化 */
        tcp_sync_mss(sk, icsk->icsk_pmtu_cookie); /* 更新MSS */
        tcp_initialize_rcv_mss(sk); /* 对端有效发送MSS估值的初始化 */

        /* Remember, tcp_poll() does not lock socket!
         * Change state from SYN-SENT only after copied_seq is initialized.
         */
        tp->copied_seq = tp->rcv_nxt; /* 更新未读数据的左端 */

        smp_mb();

        /* 走到这里，连接算是成功建立了，接下来：
         * 把连接的状态设置为TCP_ESTABLISHED。
         * 唤醒调用connect()的进程。
         */
        tcp_finish_connect(sk, skb);

        /* Fast Open选项处理 */
        if ((tp->syn_fastopen || tp->syn_data) &&
            tcp_rcv_fastopen_synack(sk, skb, &foc))
            return -1;

        /* 符合以下任一条件，则使用延迟确认，不会马上发送ACK：
         * 目前有数据等待发送。
         * 使用TCP_DEFER_ACCEPT选项。
         * 延迟确认标志为1。
         */
        if (sk->sk_write_pending || icsk->icsk_accept_queue->rskq_defer_accept ||
            icsk->icsk_ack.pingpong) {
            inet_csk_schedule_ack(sk); /* 设置ICSK_ACK_SCHED标志位，表示有ACK需要发送 */
            icsk->icsk_ack.lrcvtime = tcp_time_stamp; /* 更新最后一次接收到数据报的时间 */
            tcp_enter_quickack_mode(sk); /* 进入快速确认模式，之后会进行快速确认 */

            /* 激活延迟确认定时器，超时时间为200ms，也就是说最多延迟200ms */
            inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK, TCP_DELACK_MAX, TCP_RTO_MAX);

discard:
            __kfree_skb(skb);
            return 0;

        } else {
            tcp_send_ack(sk); /* 立即发送一个ACK，即三次握手的最后一个ACK */
        }

        return -1;
    }


    /* No ACK in the segment */

    /* 如果收到的段没有ACK标志，却设置了RST标志，那么直接丢掉 */
    if (th->rst) {
        /* rfc793:
         * If the RST bit is set and no ACK, drop the segment and return.
         */
        goto discard_and_undo;
    }

    /* PAWS check. 检查时间戳是否合法 */
    if (tp->rx_opt.ts_recent_tstamp && tp->rx_opt.saw_tstamp &&
        tcp_paws_reject(&tp->rx_opt, 0))
        goto discard_and_undo;

    /* 收到了SYN段，即同时打开 */
    if (th->syn) {

        /* We see SYN without ACK. It is attempt of simultaneous connect
         * with crossed SYNs. Particularly, it can be connect to self.
         */
         /* 发送SYN后，状态为SYN_SENT，如果此时也收到SYN，
          * 状态则变为SYN_RECV。
          */
        tcp_set_state(sk, TCP_SYN_RECV);

        if (tp->rx_opt.saw_tstamp) {
            tp->rx_opt.tstamp_ok = 1;
            tcp_store_ts_recent(tp); /* 记录对端的时间戳，作为下次发送的回显值 */
            tp->tcp_header_len = sizeof(tcphdr) + TCPOLEN_TSTAMP_ALIGNED;
        } else {
            tp->tcp_header_len = sizeof(struct tcphdr);
        }

        tp->rcv_nxt = TCP_SKB_CB(skb)->seq + 1; /* 更新接收窗口的要接收的下一个序号 */
        tp->rcv_wup = TCP_SKB_CB(skb)->seq + 1; /* 更新接收窗口的左端 */

        /* RFC1323: The window in SYN & SYN/ACK segments is never scaled.
         * 更新对端接收窗口的大小。在三次握手时，不使用窗口扩大因子。
         */
        tp->snd_wnd = ntohs(th->window);
        tp->snd_wl1 = TCP_SKB_CB(skb)->seq;  /* 记录最近更新发送窗口的ACK序号 */
        tp->max_window = tp->snd_wnd; /* 目前见过的对端的最大通告窗口 */

        /* 如果对端支持ECN，SYN会同时设置ECE和CWR标志。
         * 否则，连接就不支持ECN显式拥塞通知了。
         */
        TCP_ECN_rcv_syn(tp, th);

        tcp_mtu_init(sk); /* TCP的MTU初始化 */
        tcp_sync_mss(sk, icsk->icsk_pmtu_cookie); /* 更新MSS */
        tcp_initialize_rcv_mss(sk); /* 对端有效发送MSS估值的初始化 */

        /* 构造和发送SYNACK */
        tcp_send_synack(sk);

        goto discard;
    }

discard_and_undo:
    tcp_clear_options(&tp->rx_opt);
    tp->rx_opt.mss_clamp = saved_clamp;
    goto discard;

reset_and_undo:
    tcp_clear_options(&tp->rx_opt);
    tp->rx_opt.mss_clamp = saved_clamp;
    return 1;
}

同时打开时，在SYN_SENT状态，收到SYN段后，状态变为SYN_RECV，然后发送SYNACK。

之后如果收到合法的SYNACK后，就能完成连接的建立。

/* Send a crossed SYN-ACK during socket establishment.
 * WARNING: This routine must only be called when we have already
 * sent a SYN packet that crossed the incoming SYN that caused this
 * routine to get called. If this assumption fails then the initial rcv_wnd
 * and rcv_wscale values will not be correct.
 */

int tcp_send_synack(struct sock *sk)
{
    struct sk_buff *skb;

    skb = tcp_write_queue_head(sk); /* 发送队列的第一个段，即SYN段 */

    if (skb == NULL || ! (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN)) {
        pr_debug("%s: wrong queue state
", __func__);
        return -EFAULT;
    }

    if (! (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_ACK)) {

        /* 如果这个skb是克隆的，并且有多个使用者，那么就不能直接修改此skb。
         * 此时再克隆一个私有的nskb，替换掉之前的。然后就可以任意修改了。
         */
        if (skb_cloned(skb)) {
            struct sk_buff *nskb = skb_copy(skb, GFP_ATOMIC); /* 再克隆一份 */
            if (nskb == NULL)
                return -ENOMEM;

            tcp_unlink_write_queue(skb, sk); /* 把skb从发送队列中删除 */
            skb_header_release(nskb); /* 增加skb负荷部分的引用计数 */
            __tcp_add_write_queue_head(sk, nskb); /* 把nskb放入发送队列的头部 */
            sk_wmem_free_skb(sk, skb); /* 更新内存使用情况 */
            sk->sk_wmem_queued += nskb->truesize; /* 更新发送队列的总大小 */
            sk_mem_charge(sk, nskb->truesize); /* 更新预分配但未使用的内存大小 */
            skb = nskb; /* 接下来使用的是独占的nskb */
        }

        TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_ACK;
        TCP_ECN_send_synack(tcp_sk(sk), skb); /* 设置ECN标志位 */
    }

    TCP_SKB_CB(skb)->when = tcp_time_stamp;
    return tcp_transmit_skb(sk, skb, 1, GFP_ATOMIC); /* 发送此SYNACK段 */
}

static inline void sk_wmem_free_skb(struct sock *sk, struct sk_buff *skb)
{
    /* write queue has been shrunk recently */
    sock_set_flag(sk, SOCK_QUEUE_SHRUNK);
    sk->sk_wmem_queued -= skb->truesize; /* 更新发送队列的总大小 */
    sk_mem_uncharge(sk, skb->truesize); /* 更新预分配但未使用的内存大小 */
    __kfree_skb(skb);
}

唤醒用户进程

tcp_finish_connect()用来完成连接的建立，主要做了以下事情：

1. 把连接的状态从SYN_SENT置为ESTABLISHED。

2. 根据路由缓存，初始化TCP相关的变量。

3. 获取默认的拥塞控制算法。

4. 调整发送缓存和接收缓存的大小。

5. 如果使用了SO_KEEPALIVE选项，激活保活定时器。

6. 唤醒此socket等待队列上的进程（即调用connect的进程）。

    如果使用了异步通知，则发送SIGIO通知异步通知队列上的进程可写。

void tcp_finish_connect(struct sock *sk, struct sk_buff *skb)
{
    struct tcp_sock *tp = tcp_sk(sk);
    struct inet_connection_sock *icsk = inet_csk(sk);

    /* 连接状态从SYN_SENT变为ESTABLISHED */
    tcp_set_state(sk, TCP_ESTABLISHED);

    if (skb != NULL) {
        icsk->icsk_af_ops->sk_rx_dst_set(sk, skb);
        security_inet_conn_established(sk, skb);
    }

    /* Make sure socket is routed, for correct metrics */
    icsk->icsk_af_ops->rebuild_header(sk);

    /* 根据路由缓存，初始化TCP相关变量 */
    tcp_init_metrics(sk);

    /* 获取默认的TCP拥塞控制算法 */
    tcp_init_congestion_control(sk);

    /* Prevent spurious tcp_cwnd_restart() on first data packet. */
    tp->lsndtime = tcp_time_stamp; /* 最近发包的时间 */

    /* 调整发送缓存和接收缓存的大小 */
    tcp_init_buffer_space(sk);

    /* 如果使用了SO_KEEPALIVE选项，激活保活定时器 */
    if (sock_flag(sk, SOCK_KEEPOPEN))
        inet_csk_reset_keepalive_timer(sk, keepalive_time_when(tp));

    /* 如果对端的窗口扩大因子为0 */
    if (! tp->rx_opt.snd_wscale)
        __tcp_fast_path_on(tp, tp->snd_wnd); /* 设置首部预测字段 */
    else
        tp->pred_flags = 0;

    if (! sock_flag(sk, SOCK_DEAD)) {
        /* 指向sock_def_wakeup，唤醒调用connect()的进程 */
        sk->sk_state_change(sk);

        /* 如果使用了异步通知，则发送SIGIO通知进程可写 */
        sk_wake_async(sk, SOCK_WAKE_IO, POLL_OUT);
    }
}