注:本文分析基于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)<<req->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指针指向新建立的sock,这样在后面调用accept()时
//就能通过全连接队列上的这个请求找到这个新创建的sock,然后进行通信
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上所有睡眠的进程
- 如果有数据的话,可以着手处理数据了