TCP三次握手源码分析(服务端接收SYN以及发送SYN+ACK)

内核版本：Linux 3.10
内核源码地址：https://elixir.bootlin.com/linux/v3.10/source (包含各个版本内核源码，且网页可全局搜索函数)
接上一篇，TCP三次握手源码分析(客户端发送SYN)

一、服务端响应SYN

在服务器端，所有的TCP包(包括客户端发来的SYN握手请求)都经过网卡、软中断，进入到tcp_v4_rcv。
具体细节可以参考《Linux收包之数据从网卡到协议栈是如何流转的》、《Linux收包之数据L3层是如何流转的》

1.tcp_v4_rcv()函数，主要工作：

• 校验数据包；
• 根据网络包TCP头信息中的目的IP信息查到当前在listen的socket；
• 将数据包链入预处理队列，如果没有预处理队列，则直接调用tcp_v4_do_rcv处理数据包；

// file: net/ipv4/tcp_ipv4.c
int tcp_v4_rcv(struct sk_buff *skb)
{
    const struct iphdr *iph;
    const struct tcphdr *th;
    struct sock *sk;
    int ret;
    struct net *net = dev_net(skb->dev);

    if (skb->pkt_type != PACKET_HOST) //检查数据包类型，如果不是发给本机的就丢弃
        goto discard_it;

    /* Count it even if it's bad */
    TCP_INC_STATS_BH(net, TCP_MIB_INSEGS); //递增计数

    if (!pskb_may_pull(skb, sizeof(struct tcphdr))) //检查、调整数据包的TCP头部
        goto discard_it;

    th = tcp_hdr(skb); //指向数据包的TCP头部

    if (th->doff < sizeof(struct tcphdr) / 4) //检查TCP头部的长度
        goto bad_packet;
    if (!pskb_may_pull(skb, th->doff * 4)) //检查、调整数据包的TCP头部(这次包括TCP选项)
        goto discard_it;

    if (!skb_csum_unnecessary(skb) && tcp_v4_checksum_init(skb)) //如果没有设置校验和，就计算并初始化校验和
        goto csum_error;

    th = tcp_hdr(skb); //重新获取TCP头部(这次包括TCP选项)
    iph = ip_hdr(skb); //获取IP头部指针
    TCP_SKB_CB(skb)->seq = ntohl(th->seq); //记录序号
    TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin + skb->len - th->doff * 4); //计算结束序号
    TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq); //记录ACK序号
    TCP_SKB_CB(skb)->when     = 0; //重发参考值
    TCP_SKB_CB(skb)->ip_dsfield = ipv4_get_dsfield(iph);
    TCP_SKB_CB(skb)->sacked     = 0; //SACK标志

    // 先在已经连接的sock队列中查找(ehash)
    // 没有找到的话，就在监听的sock队列中查找(listen_hash listen的时候挂入的)，此处找到的是处于listen状态的sock
    sk = __inet_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest); //查找用于接收的sock结构
    if (!sk) //没有找到接收的sock结构就跳转到no_tcp_socket
        goto no_tcp_socket;

process:
    if (sk->sk_state == TCP_TIME_WAIT) //如果找到的sock是TIME_WAIT状态
        goto do_time_wait;

    if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
        NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
        goto discard_and_relse;
    }

    if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb)) //XFRM检测，不关心
        goto discard_and_relse;
    nf_reset(skb);

    if (sk_filter(sk, skb))
        goto discard_and_relse;

    skb->dev = NULL;

    bh_lock_sock_nested(sk);
    ret = 0;
    if (!sock_owned_by_user(sk)) { //检测sock结构是否还可用
        ......
        {
            if (!tcp_prequeue(sk, skb)) //链入预处理队列
                ret = tcp_v4_do_rcv(sk, skb); //处理数据包
        }
    } else if (unlikely(sk_add_backlog(sk, skb, sk->sk_rcvbuf + sk->sk_sndbuf))) { //如果sock结构目前不可用，就将数据包链入后备队列
        bh_unlock_sock(sk);
        NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
        goto discard_and_relse;
    }
    bh_unlock_sock(sk);  //解锁

    sock_put(sk); //递减使用计数

    return ret;

no_tcp_socket: //没有找到接收的sock结构
    if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
        goto discard_it;

    if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
csum_error:
        TCP_INC_STATS_BH(net, TCP_MIB_CSUMERRORS);
bad_packet:
        TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
    } else {
        tcp_v4_send_reset(NULL, skb); //向客户端发送RST包
    }

discard_it: //丢弃数据包
    /* Discard frame. */
    kfree_skb(skb);
    return 0;

    ......
}

 2.数据包通过tcp_prequeue()链入预处理队列，最终也是调用tcp_v4_do_rcv()函数处理。

// file: net/ipv4/tcp_ipv4.c
int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
{
    struct sock *rsk;
    ......
    if (sk->sk_state == TCP_ESTABLISHED) { //如果sock已经处于ESTABLISHED状态
        ...... //此时，服务器收到第一步握手SYN，sock还处于LISTEN状态
    }

    if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb)) //检查数据块长度，检查校验和
        goto csum_err;

    if (sk->sk_state == TCP_LISTEN) { //如果sock处理LISTEN状态
        struct sock *nsk = tcp_v4_hnd_req(sk, skb); //查找和创建代表客户端的sock结构
        if (!nsk) //没有找到，丢弃数据包
            goto discard;

        if (nsk != sk) { //如果找到的不是服务器当前的sock结构，它就是代表客户端的sock结构
            sock_rps_save_rxhash(nsk, skb);
            if (tcp_child_process(sk, nsk, skb)) { //唤醒服务器进程接收客户端连接请求
                rsk = nsk;
                goto reset;
            }
            return 0;
        }
    } else
        sock_rps_save_rxhash(sk, skb);

    if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len)) { //根据sock状态处理数据包
        rsk = sk;
        goto reset;
    }
    return 0;

reset:
    tcp_v4_send_reset(rsk, skb); //向客户端发送|RST包
    ......
}

tcp_v4_hnd_req()任然是取得了服务器的sock结构(半连接队列和ehash中都没有找到，返回了传入的sk)。

// file: net/ipv4/tcp_ipv4.c
static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
{
    struct tcphdr *th = tcp_hdr(skb);
    const struct iphdr *iph = ip_hdr(skb);
    struct sock *nsk;
    struct request_sock **prev;
    
    // 查找连接请求结构(半连接队列查找)
    struct request_sock *req = inet_csk_search_req(sk, &prev, th->source, iph->saddr, iph->daddr);
    if (req)
        return tcp_check_req(sk, skb, req, prev, false); //创建客户端的sock结构，将连接请求链入这个sock结构的接收队列中

    // 在ehash的队列中查找
    nsk = inet_lookup_established(sock_net(sk), &tcp_hashinfo, iph->saddr, th->source, iph->daddr, th->dest, inet_iif(skb));

    if (nsk) {
        if (nsk->sk_state != TCP_TIME_WAIT) { //如果不是TIME_WAIT状态
            bh_lock_sock(nsk); //加锁后返回sock结构
            return nsk;
        }
        inet_twsk_put(inet_twsk(nsk)); //释放sock结构
        return NULL;
    }

    ......
    return sk;
}

3.tcp_rcv_state_process()函数，根据sock的状态处理数据包

// file: net/ipv4/tcp_input.c
int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb, const struct tcphdr *th, unsigned int len)
{
    ......
    switch (sk->sk_state) { //判断sock状态，此时sock状态为LISTEN
    case TCP_CLOSE:
        goto discard;

    case TCP_LISTEN:
        if (th->ack) //检查ACK标识
            return 1;

        if (th->rst) //检查RST标识
            goto discard;

        if (th->syn) { //检查是否是SYN包
            if (th->fin)
                goto discard;
            if (icsk->icsk_af_ops->conn_request(sk, skb) < 0) //调用连接函数表的处理函数
                return 1;

            kfree_skb(skb); //释放数据包
            return 0;
        }
        goto discard;
    }

    ......
discard:
        __kfree_skb(skb);
    }
    return 0;
}

icsk->icsk_af_ops在创建socket的时候，挂载的是&ipv4_specific结构；

// file: net/ipv4/tcp_ipv4.c
const struct inet_connection_sock_af_ops ipv4_specific = {
    ......
    .conn_request       = tcp_v4_conn_request,
    ......
};

所以，icsk->icsk_af_ops->conn_request最终调用的是tcp_v4_conn_request()。

// file: net/ipv4/tcp_ipv4.c
int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
{
    struct tcp_options_received tmp_opt;
    struct request_sock *req;
    struct inet_request_sock *ireq;
    struct tcp_sock *tp = tcp_sk(sk);
    struct dst_entry *dst = NULL;
    __be32 saddr = ip_hdr(skb)->saddr;
    __be32 daddr = ip_hdr(skb)->daddr;
    __u32 isn = TCP_SKB_CB(skb)->when; //是否重发
    bool want_cookie = false;
    struct flowi4 fl4;
    struct tcp_fastopen_cookie foc = { .len = -1 };
    struct tcp_fastopen_cookie valid_foc = { .len = -1 };
    struct sk_buff *skb_synack;
    int do_fastopen;

    /* Never answer to SYNs send to broadcast or multicast */
    if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
        goto drop;

    // 查看半连接队列是否已经满了
    if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
        want_cookie = tcp_syn_flood_action(sk, skb, "TCP"); //判断是否开启了tcp_syncookies内核参数(/proc/sys/net/ipv4/tcp_syncookies)
        if (!want_cookie) //半连接队列满，且未开启tcp_syncookies
            goto drop;
    }

    // sk_acceptq_is_full判断全连接队列是否已满了
    // inet_csk_reqsk_queue_young(sk)记录的是半连接队列里面存在，没有被SYN_ACK重传定时器重传过SYN_ACK，同时也没有完成过三次握手的sock数量
    if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1) {
        NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
        goto drop; //半连接队列满了，同时半连接队列里尚未重传过的SYN_ACK报文个数大于1，丢弃报文
    }

    req = inet_reqsk_alloc(&tcp_request_sock_ops); //分配一个request_sock
    if (!req)
        goto drop;

#ifdef CONFIG_TCP_MD5SIG
    tcp_rsk(req)->af_specific = &tcp_request_sock_ipv4_ops;
#endif

    tcp_clear_options(&tmp_opt); //清除TCP接收选项结构(tmp_opt是局部结构变量)
    tmp_opt.mss_clamp = TCP_MSS_DEFAULT; //最大MSS值
    tmp_opt.user_mss  = tp->rx_opt.user_mss; //用户指定的MSS值
    tcp_parse_options(skb, &tmp_opt, 0, want_cookie ? NULL : &foc); //分析该请求的tcp各个选项，比如时间戳、窗口大小、快速开启等选项

    if (want_cookie && !tmp_opt.saw_tstamp)
        tcp_clear_options(&tmp_opt);

    tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
    tcp_openreq_init(req, &tmp_opt, skb); //将刚才分析的请求的TCP选项记录到刚刚分配的request_sock中

    ireq = inet_rsk(req); //获取INET的连接请求结构
    ireq->loc_addr = daddr;
    ireq->rmt_addr = saddr;
    ireq->no_srccheck = inet_sk(sk)->transparent;
    ireq->opt = tcp_v4_save_options(skb); //保存完整的IPV4选项

    ......

    // 构造 syn+ack 包
    skb_synack = tcp_make_synack(sk, dst, req,
        fastopen_cookie_present(&valid_foc) ? &valid_foc : NULL);

    if (skb_synack) {
        __tcp_v4_send_check(skb_synack, ireq->loc_addr, ireq->rmt_addr);
        skb_set_queue_mapping(skb_synack, skb_get_queue_mapping(skb));
    } else
        goto drop_and_free;

    if (likely(!do_fastopen)) {
        int err;
        // 发送 syn + ack 响应
        err = ip_build_and_send_pkt(skb_synack, sk, ireq->loc_addr, ireq->rmt_addr, ireq->opt);
        err = net_xmit_eval(err);
        if (err || want_cookie)
            goto drop_and_free;

        tcp_rsk(req)->snt_synack = tcp_time_stamp;
        tcp_rsk(req)->listener = NULL;
        // request sock添加到半连接队列，并开启重传计时器
        inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
        if (fastopen_cookie_present(&foc) && foc.len != 0)
            NET_INC_STATS_BH(sock_net(sk),
                LINUX_MIB_TCPFASTOPENPASSIVEFAIL);
    } else if (tcp_v4_conn_req_fastopen(sk, skb, skb_synack, req))
        goto drop_and_free;

    return 0;

drop_and_release:
    dst_release(dst);
drop_and_free:
    reqsk_free(req);
drop:
    NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
    return 0;
}

// file: net/ipv4/ip_output.c
int ip_build_and_send_pkt(struct sk_buff *skb, struct sock *sk, __be32 saddr, __be32 daddr, struct ip_options_rcu *opt)
{
    struct inet_sock *inet = inet_sk(sk);
    struct rtable *rt = skb_rtable(skb);
    struct iphdr *iph;

    /* Build the IP header. */
    skb_push(skb, sizeof(struct iphdr) + (opt ? opt->opt.optlen : 0));
    skb_reset_network_header(skb); //记录IP头部的位置
    iph = ip_hdr(skb); //获取IP头部
    iph->version  = 4; //设置版本号
    iph->ihl      = 5; //设置IP头部长度
    iph->tos      = inet->tos; //设置TOS值
    if (ip_dont_fragment(sk, &rt->dst)) //决定IP封包是否可以分段
        iph->frag_off = htons(IP_DF);
    else
        iph->frag_off = 0;
    iph->ttl      = ip_select_ttl(inet, &rt->dst);
    iph->daddr    = (opt && opt->opt.srr ? opt->opt.faddr : daddr);
    iph->saddr    = saddr;
    iph->protocol = sk->sk_protocol;
    ip_select_ident(iph, &rt->dst, sk);

    if (opt && opt->opt.optlen) {
        iph->ihl += opt->opt.optlen>>2;
        ip_options_build(skb, &opt->opt, daddr, rt, 0); //处理IP选项
    }

    skb->priority = sk->sk_priority;
    skb->mark = sk->sk_mark;

    /* Send it out. */
    return ip_local_out(skb); //发送数据包
}

数据经过IP层处理之后，最终从网卡发送到客户端。至此，第一次握手完成，发起第二次握手。

二、总结

1.根据SYN报文查找到服务端的监听socket(listening_hash表中查找到的)；
2.查找是否有对应的半连接socket(第一个SYN报文肯定是没有的)；
3.接着检查半连接队列和全连接队列是否满了，满了就丢弃报文；
4.然后就是创建和初始化一个request_sock，表示这个请求；
5.构造 SYN+ACK 包，发送 SYN+ACK 报文给客户端；
6.请求链入半连接队列，开启SYNACK定时器。