注：本文分析基于3.10.0-693.el7内核版本，即CentOS 7.4

客户端发送第三个握手报文ACK报文后，客户端其实就已经处于连接建立的状态，此时服务端还需要接收到这个ACK报文才算最终完成连接建立。

TCP层接收到ACK还是由tcp_v4_rcv()处理，这就是TCP层的对外接口。

int tcp_v4_rcv(struct sk_buff *skb){... //根据报文的源和目的地址在established哈希表以及listen哈希表中查找连接 //之前服务端接收到客户端的SYN报文时，socket的状态依然是listen //所以在接收到客户端的ACK时(第三次握手)，依然从listen哈希表中找到对应的连接 //这里有个疑问就是，既然此时还是listen状态，为啥所有的解释都是说在接收到SYN //报文后服务端进入SYN_RECV，连netstat命令查出来的也是。。。 sk = __inet_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest); if (!sk) goto no_tcp_socket;... ret = 0; if (!sock_owned_by_user(sk)) {//如果sk没有被用户锁定，及没在使用 if (!tcp_prequeue(sk, skb)) ret = tcp_v4_do_rcv(sk, skb);//进入到主处理函数...}

然后还是老相好tcp_v4_do_rcv()，

int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb){ struct sock *rsk;... //上面说过，此时连接状态还是listen，至少内核里是这样的 if (sk->sk_state == TCP_LISTEN) { //查找半连接队列，找到第一次握手创建的socket //并根据找到的这个socket创建一个新的socket返回 struct sock *nsk = tcp_v4_hnd_req(sk, skb); if (!nsk) goto discard; if (nsk != sk) { sock_rps_save_rxhash(nsk, skb); //处理新创建的socket if (tcp_child_process(sk, nsk, skb)) { rsk = nsk; goto reset; } return 0; } } ...}

在SYN报文接收时就会将请求放入半连接队列，因此在第三次握手时就能在半连接队列找到对应的连接了。

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) //使用这个req创建一个socket并返回 return tcp_check_req(sk, skb, req, prev, false);...}struct request_sock *inet_csk_search_req(const struct sock *sk, struct request_sock ***prevp, const __be16 rport, const __be32 raddr, const __be32 laddr){ const struct inet_connection_sock *icsk = inet_csk(sk); struct listen_sock *lopt = icsk->icsk_accept_queue.listen_opt; struct request_sock *req, **prev; //遍历半连接队列，查找对应连接 for (prev = &lopt->syn_table[inet_synq_hash(raddr, rport, lopt->hash_rnd, lopt->nr_table_entries)]; (req = *prev) != NULL; prev = &req->dl_next) { const struct inet_request_sock *ireq = inet_rsk(req); if (ireq->ir_rmt_port == rport && ireq->ir_rmt_addr == raddr && ireq->ir_loc_addr == laddr && AF_INET_FAMILY(req->rsk_ops->family)) { WARN_ON(req->sk); *prevp = prev; break; } } return req;}

找到这个半连接请求后，就根据这个请求信息创建一个新的socket，由tcp_check_req()操作。

struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb, struct request_sock *req, struct request_sock **prev, bool fastopen){ struct tcp_options_received tmp_opt; struct sock *child; const struct tcphdr *th = tcp_hdr(skb); __be32 flg = tcp_flag_word(th) & (TCP_FLAG_RST|TCP_FLAG_SYN|TCP_FLAG_ACK); bool paws_reject = false; BUG_ON(fastopen == (sk->sk_state == TCP_LISTEN)); tmp_opt.saw_tstamp = 0; if (th->doff > (sizeof(struct tcphdr)>>2)) { tcp_parse_options(skb, &tmp_opt, 0, NULL);//分析TCP头部选项 if (tmp_opt.saw_tstamp) {//如果开启了时间戳选项 //这个时间其实就是客户端发送SYN报文的时间 //req->ts_recent是在收到SYN报文时记录的 tmp_opt.ts_recent = req->ts_recent; //注释里写ts_recent_stamp表示的是记录ts_recent时的时间 //这里通过推算的方法得出ts_recent的时间,但是我觉得明显估计的不对 //按照代码说的，如果SYNACK报文没有重传(req->num_timeout=0) //那么ts_recent_stamp即为当前时间减去1 //但是收到SYN报文的时间肯定不可能是1s前，连接建立也就几毫秒的事。。。 tmp_opt.ts_recent_stamp = get_seconds() - ((TCP_TIMEOUT_INIT/HZ)<num_timeout); //确认时间戳是否回绕，比较第一次握手报文和第三次握手报文的时间戳 //没有回绕，返回false paws_reject = tcp_paws_reject(&tmp_opt, th->rst); } } //如果接收到的报文序列号等于之前SYN报文的序列号，说明这是一个重传SYN报文 //如果SYN报文时间戳没有回绕，那就重新发送SYNACK报文，然后更新半连接超时时间 if (TCP_SKB_CB(skb)->seq == tcp_rsk(req)->rcv_isn && flg == TCP_FLAG_SYN && !paws_reject) { if (!tcp_oow_rate_limited(sock_net(sk), skb, LINUX_MIB_TCPACKSKIPPEDSYNRECV, &tcp_rsk(req)->last_oow_ack_time) && !inet_rtx_syn_ack(sk, req))//没有超过速率限制，那就重发SYNACK报文 req->expires = min(TCP_TIMEOUT_INIT << req->num_timeout, TCP_RTO_MAX) + jiffies;//更新半连接的超时时间 return NULL; } //收到的ACK报文的确认号不对，返回listen socket if ((flg & TCP_FLAG_ACK) && !fastopen && (TCP_SKB_CB(skb)->ack_seq != tcp_rsk(req)->snt_isn + 1)) return sk; /* Also, it would be not so bad idea to check rcv_tsecr, which * is essentially ACK extension and too early or too late values * should cause reset in unsynchronized states. */ /* RFC793: "first check sequence number". */ //报文时间戳回绕，或者报文序列不在窗口范围，发送ACK后丢弃 if (paws_reject || !tcp_in_window(TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq, tcp_rsk(req)->rcv_nxt, tcp_rsk(req)->rcv_nxt + req->rcv_wnd)) { /* Out of window: send ACK and drop. */ if (!(flg & TCP_FLAG_RST)) req->rsk_ops->send_ack(sk, skb, req); if (paws_reject) NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSESTABREJECTED); return NULL; } /* In sequence, PAWS is OK. */ //开启了时间戳，且收到的报文序列号小于等于期望接收的序列号 if (tmp_opt.saw_tstamp && !after(TCP_SKB_CB(skb)->seq, tcp_rsk(req)->rcv_nxt)) req->ts_recent = tmp_opt.rcv_tsval;//更新ts_recent为第三次握手报文的时间戳 //清除SYN标记  if (TCP_SKB_CB(skb)->seq == tcp_rsk(req)->rcv_isn) { /* Truncate SYN, it is out of window starting at tcp_rsk(req)->rcv_isn + 1. */ flg &= ~TCP_FLAG_SYN; } /* RFC793: "second check the RST bit" and * "fourth, check the SYN bit" */ if (flg & (TCP_FLAG_RST|TCP_FLAG_SYN)) { TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_ATTEMPTFAILS); goto embryonic_reset; } /* ACK sequence verified above, just make sure ACK is * set. If ACK not set, just silently drop the packet. * * XXX (TFO) - if we ever allow "data after SYN", the * following check needs to be removed. */ if (!(flg & TCP_FLAG_ACK)) return NULL; /* For Fast Open no more processing is needed (sk is the * child socket). */ if (fastopen) return sk; /* While TCP_DEFER_ACCEPT is active, drop bare ACK. */ //设置了TCP_DEFER_ACCEPT，即延迟ACK选项，且该ACK没有携带数据，那就先丢弃 if (req->num_timeout < inet_csk(sk)->icsk_accept_queue.rskq_defer_accept && TCP_SKB_CB(skb)->end_seq == tcp_rsk(req)->rcv_isn + 1) { inet_rsk(req)->acked = 1;//标记已经接收过ACK报文了 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPDEFERACCEPTDROP); return NULL; } /* OK, ACK is valid, create big socket and * feed this segment to it. It will repeat all * the tests. THIS SEGMENT MUST MOVE SOCKET TO * ESTABLISHED STATE. If it will be dropped after * socket is created, wait for troubles. */ //这里总算是正常ACK报文了，创建一个新的socket并返回 child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL); if (child == NULL) goto listen_overflow; //将老的socket从半连接队列里摘链 inet_csk_reqsk_queue_unlink(sk, req, prev); //删除摘除的请求，然后更新半连接队列的统计信息 //如果半连接队列为空，删除SYNACK定时器 inet_csk_reqsk_queue_removed(sk, req); //将新创建的新socket加入全连接队列里，并更新队列统计信息 inet_csk_reqsk_queue_add(sk, req, child); return child;...}

找到半连接队列里的请求后，还需要和当前接收到的报文比较，检查是否出现时间戳回绕的情况(timestamps选项开启的前提下)，通过tcp_paws_reject()检测。

static inline bool tcp_paws_reject(const struct tcp_options_received *rx_opt, int rst){ //检查时间戳是否回绕 if (tcp_paws_check(rx_opt, 0)) return false; //第三次握手报文一般都不会有rst标志 //另一个条件是，当前时间和上次该ip通信的时间间隔大于TCP_PAWS_MSL(60s), //即一个time_wait状态持续时间 if (rst && get_seconds() >= rx_opt->ts_recent_stamp + TCP_PAWS_MSL) return false; return true;}static inline bool tcp_paws_check(const struct tcp_options_received *rx_opt, int paws_win){ //rx_opt->ts_recent是SYN报文发送时间， //rx_opt->rcv_tsval是客户端发送第三次握手报文的时间 //也就是要保证时间戳没有回绕，正常情况下这里就满足返回了 if ((s32)(rx_opt->ts_recent - rx_opt->rcv_tsval) <= paws_win) return true; //距离上一次收到这个ip的报文过去了24天，一般不可能 if (unlikely(get_seconds() >= rx_opt->ts_recent_stamp + TCP_PAWS_24DAYS)) return true; //没有开启时间戳 if (!rx_opt->ts_recent) return true; return false;}

确认时间戳未发生回绕后，看下是不是重传的SYN报文，如果是那就重发SYNACK报文，并重置SYNACK定时器。

接下来一个比较重要的点就是，如果开启了TCP_DEFER_ACCEPT选项，即延迟ACK选项，但是接收到的这个ACK没有携带数据，那就先丢弃，标记收到过ACK报文，等待后续客户端发送数据再做连接建立的真正操作。

重重检查后，总算是要创建新的socket了，因此inet_csk(sk)->icsk_af_ops->syn_recv_sock上场了。我们熟悉的icsk_af_ops又来了，它指向的是ipv4_specific，

const struct inet_connection_sock_af_ops ipv4_specific = { .queue_xmit = ip_queue_xmit, .send_check = tcp_v4_send_check, .rebuild_header = inet_sk_rebuild_header, .sk_rx_dst_set = inet_sk_rx_dst_set, .conn_request = tcp_v4_conn_request, .syn_recv_sock = tcp_v4_syn_recv_sock, ...};

所以创建新socket就是tcp_v4_syn_recv_sock()完成的。

/* * The three way handshake has completed - we got a valid synack - * now create the new socket. */struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb, struct request_sock *req, struct dst_entry *dst){ struct inet_request_sock *ireq; struct inet_sock *newinet; struct tcp_sock *newtp; struct sock *newsk;#ifdef CONFIG_TCP_MD5SIG struct tcp_md5sig_key *key;#endif struct ip_options_rcu *inet_opt; //如果全连接队列已经满了，那就丢弃报文 if (sk_acceptq_is_full(sk)) goto exit_overflow; //创建一个新的socket用于连接建立后的处理，原来的socket继续监听新发起的连接 newsk = tcp_create_openreq_child(sk, req, skb); if (!newsk) goto exit_nonewsk;... //处理新创建的socket的端口，一般就是和原来监听socket使用同一个端口 if (__inet_inherit_port(sk, newsk) < 0) goto put_and_exit; //将新创建的新socket加入established哈希表中 __inet_hash_nolisten(newsk, NULL); return newsk;...}

检查全连接队列是否满了，满了就丢弃报文，否则请出tcp_create_openreq_child()创建新socket。

struct sock *tcp_create_openreq_child(struct sock *sk, struct request_sock *req, struct sk_buff *skb){ //创建子socket struct sock *newsk = inet_csk_clone_lock(sk, req, GFP_ATOMIC); //接下来就是新socket的各种初始化了 if (newsk != NULL) { const struct inet_request_sock *ireq = inet_rsk(req); struct tcp_request_sock *treq = tcp_rsk(req); struct inet_connection_sock *newicsk = inet_csk(newsk); struct tcp_sock *newtp = tcp_sk(newsk); ... //初始化新socket的各个定时器 tcp_init_xmit_timers(newsk); ... //如果开启时间戳 if (newtp->rx_opt.tstamp_ok) { //记录第三次握手报文发送的时间，上面的流程已经将ts_recent更新 newtp->rx_opt.ts_recent = req->ts_recent; newtp->rx_opt.ts_recent_stamp = get_seconds(); newtp->tcp_header_len = sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED; } else { newtp->rx_opt.ts_recent_stamp = 0; newtp->tcp_header_len = sizeof(struct tcphdr); } ... } return newsk;}struct sock *inet_csk_clone_lock(const struct sock *sk, const struct request_sock *req, const gfp_t priority){ struct sock *newsk = sk_clone_lock(sk, priority); if (newsk != NULL) { struct inet_connection_sock *newicsk = inet_csk(newsk); //新创建的socket状态设置为SYN_RECV newsk->sk_state = TCP_SYN_RECV; newicsk->icsk_bind_hash = NULL; //记录目的端口，以及服务器端端口 inet_sk(newsk)->inet_dport = inet_rsk(req)->ir_rmt_port; inet_sk(newsk)->inet_num = inet_rsk(req)->ir_num; inet_sk(newsk)->inet_sport = htons(inet_rsk(req)->ir_num); newsk->sk_write_space = sk_stream_write_space; inet_sk(newsk)->mc_list = NULL; newicsk->icsk_retransmits = 0;//重传次数 newicsk->icsk_backoff = 0;//退避指数 newicsk->icsk_probes_out = 0; /* Deinitialize accept_queue to trap illegal accesses. */ memset(&newicsk->icsk_accept_queue, 0, sizeof(newicsk->icsk_accept_queue)); security_inet_csk_clone(newsk, req); } return newsk;}

从inet_csk_clone_lock()中我们终于看到socket的状态进入SYN_RECV了，千呼万唤始出来啊，这都是第三次握手报文了，说好的接收到SYN报文就进入SYN_RECV的呢，骗得我好苦。

创建好新的socket后，需要将该socket归档，处理其使用端口，并且放入bind哈希表，这样之后我们才能查询得到这个新的socket。

int __inet_inherit_port(struct sock *sk, struct sock *child){ struct inet_hashinfo *table = sk->sk_prot->h.hashinfo; unsigned short port = inet_sk(child)->inet_num; const int bhash = inet_bhashfn(sock_net(sk), port, table->bhash_size); struct inet_bind_hashbucket *head = &table->bhash[bhash]; struct inet_bind_bucket *tb; spin_lock(&head->lock); tb = inet_csk(sk)->icsk_bind_hash; //一般新socket和原先的socket端口都是一样的 if (tb->port != port) { /* NOTE: using tproxy and redirecting skbs to a proxy * on a different listener port breaks the assumption * that the listener socket's icsk_bind_hash is the same * as that of the child socket. We have to look up or * create a new bind bucket for the child here. */ inet_bind_bucket_for_each(tb, &head->chain) { if (net_eq(ib_net(tb), sock_net(sk)) && tb->port == port) break; } if (!tb) { tb = inet_bind_bucket_create(table->bind_bucket_cachep, sock_net(sk), head, port); if (!tb) { spin_unlock(&head->lock); return -ENOMEM; } } } //将新的socket加入bind哈希表中 inet_bind_hash(child, tb, port); spin_unlock(&head->lock); return 0;}

但是加入bind哈希表并不足够，bind哈希表只是存储绑定的ip和端口信息，还需要以下几个动作：

将新建的socket加入establish哈希表 将原先老的socket从半连接队列里拆除并更新半连接统计信息 将新建的socket加入全连接队列

加入全连接队列由inet_csk_reqsk_queue_add()操作，

static inline void inet_csk_reqsk_queue_add(struct sock *sk, struct request_sock *req, struct sock *child){ reqsk_queue_add(&inet_csk(sk)->icsk_accept_queue, req, sk, child);}static inline void reqsk_queue_add(struct request_sock_queue *queue, struct request_sock *req, struct sock *parent, struct sock *child){ req->sk = child; sk_acceptq_added(parent); if (queue->rskq_accept_head == NULL) queue->rskq_accept_head = req; else queue->rskq_accept_tail->dl_next = req; queue->rskq_accept_tail = req; req->dl_next = NULL;}static inline void sk_acceptq_added(struct sock *sk){  //全连接队列里连接数量统计更新 sk->sk_ack_backlog++;}

有一点要注意的就是，加入半连接队列的函数是inet_csk_reqsk_queue_added()，和加入全连接队列的函数就差一个单词，一个是add，一个是added，别混淆了。

返回这个新创建的socket后，就进入tcp_child_process()函数继续深造。

int tcp_child_process(struct sock *parent, struct sock *child, struct sk_buff *skb){ int ret = 0; int state = child->sk_state; //新的socket没有没用户占用 if (!sock_owned_by_user(child)) { //对，又是它，就是它，处理各种状态socket的接口 ret = tcp_rcv_state_process(child, skb, tcp_hdr(skb), skb->len); /* Wakeup parent, send SIGIO */ if (state == TCP_SYN_RECV && child->sk_state != state) parent->sk_data_ready(parent, 0); } else { /* Alas, it is possible again, because we do lookup * in main socket hash table and lock on listening * socket does not protect us more. */ //用户占用则加入backlog队列 __sk_add_backlog(child, skb); } bh_unlock_sock(child); sock_put(child); return ret;}

接着socket就要从SYN_RECV进入ESTABLISHED状态了，这就又要tcp_rcv_state_process()出马了。

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;... req = tp->fastopen_rsk;//快速开启选项相关... /* step 5: check the ACK field */ //检查ACK确认号的合法值 acceptable = tcp_ack(sk, skb, FLAG_SLOWPATH | FLAG_UPDATE_TS_RECENT) > 0; switch (sk->sk_state) { //这个是新创建的socket，所以此时状态是SYN_RECV case TCP_SYN_RECV: if (!acceptable) return 1; /* Once we leave TCP_SYN_RECV, we no longer need req * so release it. */ if (req) {//快速开启走这个流程 synack_stamp = tcp_rsk(req)->snt_synack; tp->total_retrans = req->num_retrans; reqsk_fastopen_remove(sk, req, false); } else { //非快速开启流程 synack_stamp = tp->lsndtime; /* Make sure socket is routed, for correct metrics. */ icsk->icsk_af_ops->rebuild_header(sk); tcp_init_congestion_control(sk);//初始化拥塞控制 //mtu探测初始化 tcp_mtup_init(sk); tp->copied_seq = tp->rcv_nxt; //初始化接收和发送缓存空间 tcp_init_buffer_space(sk); } smp_mb(); //服务端连接状态终于抵达终点，established tcp_set_state(sk, TCP_ESTABLISHED); //调用sock_def_wakeup唤醒该sock上等待队列的所有进程 sk->sk_state_change(sk); /* Note, that this wakeup is only for marginal crossed SYN case. * Passively open sockets are not waked up, because * sk->sk_sleep == NULL and sk->sk_socket == NULL. */ //对于服务端是被动开启socket，所以不会走这个流程 if (sk->sk_socket) sk_wake_async(sk, SOCK_WAKE_IO, POLL_OUT); ... } /* step 6: check the URG bit */ tcp_urg(sk, skb, th); /* step 7: process the segment text */ switch (sk->sk_state) { ... case TCP_ESTABLISHED: //这时socket已经是established状态了，可以处理及接收数据了 tcp_data_queue(sk, skb); queued = 1; break; } /* tcp_data could move socket to TIME-WAIT */ if (sk->sk_state != TCP_CLOSE) { tcp_data_snd_check(sk); tcp_ack_snd_check(sk); } if (!queued) {discard: __kfree_skb(skb); } return 0;}

终于的终于，服务端也到达established状态，连接总算是可靠的建立了。

我们大概总结下第三次握手报文的接收处理流程：

查找半连接队列获取该连接之前的请求req 判断是否是重传SYN报文，是的话重传SYNACK报文，并重置SYNACK定时器 如果开启了延迟ACK选项，且ACK报文未携带数据，丢弃报文 根据半连接队列的req，创建一个新的socket，将其状态置为SYN_RECV 将新创建的socket加入bind哈希表和establisted哈希表 将原来老的监听socket移出半连接队列并更新信息 将新创建的socket加入全连接队列并更新统计信息 新建的socket进入ESTABLISHED状态，唤醒该socket上所有睡眠的进程 如果有数据的话，可以着手处理数据了