Linux：TCP 序列号简介

news2024/11/28 14:42:55

文章目录

  • 1. 前言
  • 2. 什么是 TCP 序列号？
  • 3. TCP 序号 的 初始值设置 和 后续变化过程
    • 3.1 三次握手 连接建立 期间 客户端 和 服务端 序号 的 变化过程
      • 3.1.1 客户端 socket 初始序号 的 建立
      • 3.1.2 服务端 socket 初始序号 的 建立
      • 3.1.3 客户端 socket 接收 服务端 SACK，然后回复 服务端 ACK
      • 3.1.4 服务端 接收 客户端 ACK，完成 三次握手
      • 3.1.5 三次握手期间的序号变化总结
    • 3.2 连接建立后，数据 通信 过程中 序号 的变化
    • 3.3 四次挥手 连接断开 期间 序号 的变化

1. 前言

限于作者能力水平，本文可能存在谬误，因此而给读者带来的损失，作者不做任何承诺。

2. 什么是 TCP 序列号？

TCP 序列号，是为 TCP 协议通信数据中的每一个字节赋予一个唯一编号，其作用可以概括如下：

1. 数据分段(Segment)与重组
   一次发送的数据长度如果超过设定的 MSS(Maximum Segment Size)，就会被分成多个带有 TCP 
   协议头的段(Segment)分别发送出去；接收端需将接收的分段(Segment)数据按每个 TCP 数据段
   (Segment)头部中的序列号来进行重组。
2. 数据的可靠性传输
   接收端在收到发送端的数据后，通过 ACK 返回接收数据的序列号，这样发送端就可以确认数据已
   抵达接收端。
3. 流量控制
   TCP 通过滑动窗口来进行流量控制。通信两端各自维护自身的 发送 和 接收滑动窗口大小，并将
   自身接收滑动窗口大小 和 序列号 发送给对端，让对端知道当前最大可以发送的数据量。
4. 防止重复报文
   TCP 有超时重发机制，如果发送的数据超过一定时间没有收到对方的确认ACK，则会认为数据可能
   丢失而进行重发。在有些情形下，数据并没有丢失，只是因为某些原因导致在发送路途中消耗时间
   过长，如果这个时间超过了 TCP 的超时重发时间，则接收端会重复接收到同一数据，这时可通过
   丢弃具有相同序列号的数据来去重。

一图胜千言，还是上一张图来直观感受下：
在这里插入图片描述
上图是 TCP 协议数据头部，红框中的部分：序号 表示发送端所发送数据的序列号；确认号 表示接收端已收到发送端序号为确认号之前的所有数据，回送确认号告诉发送端，可以继续发送序号从确认号开始的数据。TCP 序列号以一个 32 位无符号数 表示，最大值为 2^32 - 1，到达最大值后回卷到 0 。

3. TCP 序号 的 初始值设置 和 后续变化过程

从前面的章节中，我们对 TCP 序号 有了一个初步了解，本文剩余部分将结合图示和内核源码，来说说 连接建立初期 TCP 序号初始值的设定过程、以及 连接建立后 TCP 通信当中序号的变化过程。
在正式讨论 TCP 序号 的相关细节前，首先要明确的是，TCP 序号 是基于每 socket 进行维护的，即每个 socket 都有自己独立的序号，从后面的代码分析我们将看到这一点。
本文以典型的 TCP 服务端 和 客户端 通信过程，说明 TCP 序号 的维护细节。本文基于 Linux 4.14 内核源码进行分析。先上两张图，分别描述了 TCP 套接字状态机 和 TCP socket 通信序列号变化过程(包括 三握四挥、数据传输)，如下：
在这里插入图片描述
在这里插入图片描述

3.1 三次握手 连接建立 期间 客户端 和 服务端 序号 的 变化过程

TCP 服务端 和 客户端 socket 各自的 序号初始值 在连接建立的 三次握手 过程中建立，分析过程参考上面的第二张图进行(我们假定 服务端 当前处于 LISTEN 态(TCP_LISTEN)(即已经调用了 listen())。

3.1.1 客户端 socket 初始序号 的 建立

客户端 socket 通过 connect() 系统调用，构建 SYN 包 向 服务端 发起连接请求，其 初始序号 建立的主要流程如下：

sys_connect()
	...
	tcp_v4_connect()
		...
		tcp_set_state(sk, TCP_SYN_SENT); /* 标记 客户端 socket 进入 TCP_SYN_SENT 状态 */
		...
		tp->write_seq = secure_tcp_seq(...); /* 初始化 客户端 socket 序号 为 随机值 x (假定 x = 4065008942) */
		...
		tcp_connect(sk);
			struct tcp_sock *tp = tcp_sk(sk); /* 客户端 TCP socket 对象 */
 			struct sk_buff *buff;
 			
			...
			buff = sk_stream_alloc_skb(sk, 0, sk->sk_allocation, true); /* 为 SYN 包分配空间 */
			...
			/*
 			 * 初始化 TCP SYN 包 TCP 控制块(tcp_skb_cb): 
			  * . 设置 SYN 包 初始 序号
			  * . 设置 SYN 包 SYN 标志
			  */
			tcp_init_nondata_skb(buff, tp->write_seq++, TCPHDR_SYN);
				TCP_SKB_CB(skb)->tcp_flags = flags; /* 设置 SYN 标志位 */
 				TCP_SKB_CB(skb)->sacked = 0;
 				...
				TCP_SKB_CB(skb)->seq = seq; /* SYN 包 序号 设为 x (x = 4065008942) */
				...
			...
			tcp_transmit_skb(sk, buff, 1, sk->sk_allocation);
				__tcp_transmit_skb(sk, skb, clone_it, gfp_mask, tcp_sk(sk)->rcv_nxt);
					struct tcphdr *th; /* TCP 数据包头部 */
					...
					th->seq   = htonl(tcb->seq); /* 客户端 发往 服务端 SYN 包：序号 为 x (x = 4065008942) */
					th->ack_seq  = htonl(rcv_nxt); /* 客户端 发往 服务端 的 SYN 包：确认号 为 0 */
					/* 设置 SYN 标志位 */
					*(((__be16 *)th) + 6) = htons(((tcp_header_size >> 2) << 12) | tcb->tcp_flags);
					...
			...
			tp->snd_nxt = tp->write_seq; /* 更新 套接字 的 发送滑动窗口 下一要发送字节 的 序号 */
			...

从上面的代码分析看到，客户端 socket 在 connect() 中构建一个 SYN 包，在 SYN 包 构建过程中确定了 初始序号，且设置了 SYN 标志位。此时 客户端 socket 的状态 也由 CLOSED(TCP_CLOSED) 转化为 SYN-SENT(TCP_SYN_SENT) 。用 tcpdump 在 服务端 抓包，结果如下：

00:30:27.921869 IP 169.228.88.168.52524 > 169.228.88.188.8888: Flags [S], seq 4065008942, win 64240, options [mss 1460,sackOK,TS val 3875254422 ecr 0,nop,wscale 7], length 0

可以看到，服务端 169.228.88.188.8888 收到了从 客户端 169.228.88.168.52524 发送的 SYN 包，客户端初始序号 为 x=4065008942 。tcpdump 用 [S] 标记 SYN 包。

3.1.2 服务端 socket 初始序号 的 建立

服务端 收到 客户端 序号 为 x 的 SYN 包 后，会回复 确认号 为 x+1 的 ACK 给 客户端；同时构建一个 序号 为 y 的 SYN 包，向 客户端 发起连接请求。很自然的，服务端 将 回复 ACK 和 请求 SYN 放在同一个 TCP 包里，一同发往 客户端，而不是分开发送，这就是平常所见的 SACK 包，或者 SYN + ACK 包。前述过程的主要代码流程如下：

/* 
 * 从网卡接收数据中断接口开始: 
 * 服务端 收到 客户端 的 SYN 连接请求后，回复 客户端 SYN + ACK.
 */
xxx_nic_interrput()
	...
	ip_rcv()
		...
		tcp_v4_rcv()
			...
			const struct iphdr *iph; /* IP 头部 */
			const struct tcphdr *th; /* TCP 头部 */
			...
			struct sock *sk; /* TCP 服务端 socket 对象 */
			...

			/* 找到 TCP 服务端 socket 对象 */
			th = (const struct tcphdr *)skb->data;
 			iph = ip_hdr(skb);
 		lookup:
			sk = __inet_lookup_skb(&tcp_hashinfo, skb, __tcp_hdrlen(th), th->source,
						th->dest, sdif, &refcounted);	
			
			...
			
			 /* 从 客户端 socket 发送的 SYN 包 提取 序号 x (x = 4065008942)、确认号 等(到 TCP 控制块 struct tcp_skb_cb) */
			th = (const struct tcphdr *)skb->data;
			iph = ip_hdr(skb);
			tcp_v4_fill_cb(skb, iph, th);
				TCP_SKB_CB(skb)->seq = ntohl(th->seq); /* TCP_SKB_CB(skb)->seq = x; (x = 4065008942)  */
				...
				TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq); /* 0 */
				...
				TCP_SKB_CB(skb)->tcp_flags = tcp_flag_byte(th); /* SYN */
 				TCP_SKB_CB(skb)->tcp_tw_isn = 0;
 				...
			...
 			if (sk->sk_state == TCP_LISTEN) { /* TCP 服务端 socket 当前处于 LISTEN 状态(TCP_LISTEN) */
 				ret = tcp_v4_do_rcv(sk, skb);
 					...
 					tcp_rcv_state_process(sk, skb))
 						struct tcp_sock *tp = tcp_sk(sk);
 						...
 						const struct tcphdr *th = tcp_hdr(skb);
 						...
 						
 						switch (sk->sk_state) {
 						...
 						case TCP_LISTEN: /* TCP 服务端 socket 当前处于 LISTEN 状态(TCP_LISTEN) */
 							...
 							if (th->syn) { /* 是 客户端 socket 发送的 SYN 包(设置了 SYN 标志位) */
 								...
 								/* 调用 tcp_v4_conn_request(), 见后续分析 */
 								acceptable = icsk->icsk_af_ops->conn_request(sk, skb) >= 0;
 								...
 								
 								consume_skb(skb); /* 消耗 客户端 socket 的 SYN 包 */
 								return 0;
 							}
 							...
 						...
 						}
 					...
 				...
 			}

/* 接上面的分析 */
acceptable =  tcp_v4_conn_request(sk, skb) >= 0;
	tcp_conn_request(&tcp_request_sock_ops, &tcp_request_sock_ipv4_ops, sk, skb);
		...
		__u32 isn = TCP_SKB_CB(skb)->tcp_tw_isn; // 0
		...
		/* 服务端 TCP socket, 在关闭前会一直处于 TCP_LISTEN 态, 通过 accept() 接收客户端的 SYN 连接请求 */
		struct tcp_sock *tp = tcp_sk(sk);
		...
		/* 即将 在 服务端 新建一个 socket 对象, 和 客户端 发起连接 的 socket 通信 */
		struct request_sock *req;
		...

		/*
		 * !!!
		 * 为 客户端 连接请求 分配 轻量 socket 对象 struct request_sock.
		 * 记住 这个 轻量 socket 对象，它将用于 服务端 在接收 客户端 ACK 的处理.
		 */
		req = inet_reqsk_alloc(rsk_ops, sk, !want_cookie); /* (1) */
			struct request_sock *req = reqsk_alloc(ops, sk_listener, attach_listener);
				struct request_sock *req;
				
				req = kmem_cache_alloc(ops->slab, GFP_ATOMIC | __GFP_NOWARN);
				...
				if (attach_listener) {
					...
					/* 
					 * 记录 客户端 连接信息 的 轻量 socket 是 向 服务端 socket 对象 @sk_listener
					 * 发起的，即 @req->rsk_listener 记录了 服务端 socket 对象。
					 */
					req->rsk_listener = sk_listener;
				}
				...
			
			if (req) {
				struct inet_request_sock *ireq = inet_rsk(req);
				
				...
				/* 记录 客户端 连接的 轻量 socket 初始为 SYN-RECEIVED(TCP_NEW_SYN_RECV) 态 */
				ireq->ireq_state = TCP_NEW_SYN_RECV;
				write_pnet(&ireq->ireq_net, sock_net(sk_listener));
  				ireq->ireq_family = sk_listener->sk_family;
			}
		...

		tcp_rsk(req)->af_specific = af_ops; /* &tcp_request_sock_ipv4_ops */
		...

		tcp_openreq_init(req, &tmp_opt, skb, sk);
			...
			
			req->rsk_rcv_wnd = 0;
			...
			/* 记录 客户端 的 初始序号 x (x = 4065008942) */
			tcp_rsk(req)->rcv_isn = TCP_SKB_CB(skb)->seq; /* tcp_rsk(req)->rcv_isn = x; */
			/* 服务端 期待 收到 的 下一 客户端 数据的 序号 x + 1 (x + 1 = 4065008942 + 1 = 4065008943) */
			tcp_rsk(req)->rcv_nxt = TCP_SKB_CB(skb)->seq + 1; /* tcp_rsk(req)->rcv_nxt = x + 1;  */
			...
		...

		/* 为 服务端 新建的、用来和 客户端 通信的 socket 生成 初始 序号(ISN: Initial Sequence Number) */
		if (!want_cookie && !isn) {
			...
			isn = af_ops->init_seq(skb); /* tcp_v4_init_seq() */
				tcp_v4_init_seq(skb)
					secure_tcp_seq(...)
		}

		/* 设定 服务端 新建的、用来和 客户端 通信 socket 的 初始 序号 y (假定 y = 1093122830) */
		tcp_rsk(req)->snt_isn = isn;
		...
		if (fastopen_sk) {
			...
		} else {
			if (!want_cookie)
				/* 将记录 客户端 连接的 轻量级 的 socket 添加到 服务端 socket 的 SYN 队列(半连接队列) */
				inet_csk_reqsk_queue_hash_add(sk, req, 
						tcp_timeout_init((struct sock *)req));
			/* 服务端 回复 客户端 ACK，同时发送 SYN 连接请求 (tcp_v4_send_synack()) */
			af_ops->send_synack(sk, dst, &fl, req, &foc,
				    	!want_cookie ? TCP_SYNACK_NORMAL : TCP_SYNACK_COOKIE);
				tcp_v4_send_synack(sk, dst, &fl, req, &foc, TCP_SYNACK_NORMAL)
					...
					/*
 					 * 构建 SYN + ACK 包: 
 					 * . ACK 是对 客户端 SYN 连接请求的回复;
 					 * . SYN 是 服务端 向 客户端 发起的连接请求.
 					 */
					skb = tcp_make_synack(sk, dst, req, foc, synack_type);
						struct tcphdr *th;
						...
						
						skb = alloc_skb(MAX_TCP_HEADER, GFP_ATOMIC); /* 分配 skb 空间 */
						...
						
						th = (struct tcphdr *)skb->data;
						memset(th, 0, sizeof(struct tcphdr));
						th->syn = 1; /* 设置 SYN 标志位 */
						th->ack = 1; /* 设置 ACK 标志位 */
						...
						/* th->seq = y; (y = 1093122830) */
						th->seq = htonl(tcp_rsk(req)->snt_isn);
						/* th->ack_seq = x + 1; (x + 1 = 4065008942 + 1 = 4065008943) */
						th->ack_seq = htonl(tcp_rsk(req)->rcv_nxt);
						...
						
					if (skb) {
						...
						/* 服务端 回复 客户端 SYN 请求 ACK, 同时向 客户端 发送 连接请求 SYN */
						err = ip_build_and_send_pkt(skb, sk, ireq->ir_loc_addr,
									ireq->ir_rmt_addr,
									rcu_dereference(ireq->ireq_opt));
						...
					}
		}

3.1.3 客户端 socket 接收 服务端 SACK，然后回复 服务端 ACK

接下来 客户端 socket 收到 服务端 的 SYN + ACK 包，其中 ACK 是 服务端 对 客户端 SYN 的回复，而 SYN 是来自 服务端 的连接请求。从 3.1.1 的分析了解到，客户端套接字当前处于 SYN-SENT(TCP_SYN_SENT) 状态。来看 客户端 收取 服务端 ACK 并 回复 服务端 SYN 的 ACK 的代码细节：

/*
 * 从网卡接收数据中断接口开始:
 * 客户端 接收 服务端 对 自身 SYN 请求的 ACK, 并对 服务端 的 SYN 请求 回复 ACK.
 */
xxx_nic_interrput()
	...
	ip_rcv()
		tcp_v4_rcv()
			...
			if (!sock_owned_by_user(sk)) {
				ret = tcp_v4_do_rcv(sk, skb);
					...
					tcp_rcv_state_process(sk, skb)
						...
						switch (sk->sk_state) {
						...
						case TCP_SYN_SENT: /* 客户端 socket 当前处于 SYN-SENT(TCP_SYN_SENT) 态 */
							queued = tcp_rcv_synsent_state_process(sk, skb, th); /* 见后续分析 */
							...
							return 0;
						...
						}
			} else if (tcp_add_backlog(sk, skb)) {
				...
			}
			...

/* 接上面的分析 */
queued = tcp_rcv_synsent_state_process(sk, skb, th);
	...
	if (th->ack) { /* 客户端 收到 服务端 对 SYN 回复的 SYN + ACK */
		...
		
		if (!th->syn) /* 不是 (SYN + ACK) */
   			goto discard_and_undo;
   		
   		...

		/* 客户端 期待的 服务端 的下一数据 序号 y + 1 */
		tp->rcv_nxt = TCP_SKB_CB(skb)->seq + 1; /* tp->rcv_nxt = y + 1; (y + 1 = 1093122830 + 1 = 1093122831) */
  		tp->rcv_wup = TCP_SKB_CB(skb)->seq + 1;

		...
		
		/*
		 * 客户端 完成 连接建立工作：
		 * 客户端 socket 由 SYN-SENT(TCP_SYN_SENT) 转为 ESTABLISHED(TCP_ESTABLISHED) 态. 
		 */
		tcp_finish_connect(sk, skb);
			...
			tcp_set_state(sk, TCP_ESTABLISHED); /* 客户端 socket 进入 ESTABLISHED(TCP_ESTABLISHED) 态 */
			...
		...

		if (...) {
			...
		}  else {
			tcp_send_ack(sk); /* 构建 + 向 服务端 回送 ACK 包 */
				__tcp_send_ack(sk, tcp_sk(sk)->rcv_nxt);
					struct sk_buff *buff;
					...
					buff = alloc_skb(MAX_TCP_HEADER, ...);
					...
					tcp_init_nondata_skb(buff, tcp_acceptable_seq(sk), TCPHDR_ACK);
						
					...
					__tcp_transmit_skb(sk, buff, 0, (__force gfp_t)0, rcv_nxt);
						...
						struct tcp_skb_cb *tcb;
						...
						struct tcphdr *th;
						...
						
						tcb = TCP_SKB_CB(skb);
						...
						th = (struct tcphdr *)skb->data;
						...
						/* th->seq = x + 1; (x + 1 = 4065008942 + 1 = 4065008943) */
						th->seq   = htonl(tcb->seq);
						/* th->ack_seq = y + 1; (y + 1 = 1093122830 + 1 = 1093122831) */
 						th->ack_seq  = htonl(rcv_nxt); 
 						/* 设置 TCP 头部的 ACK 标记 */
 						*(((__be16 *)th) + 6) = htons(((tcp_header_size >> 2) << 12) | 
 										tcb->tcp_flags);
 						...
 						/* 将 ACK 向下传递给 网络层 发送出去 */
 						err = icsk->icsk_af_ops->queue_xmit(sk, skb, &inet->cork.fl); /* ip_queue_xmit() */
		}
		...
	}

至此，客户端 ==> 服务端 的 单边连接 已经建立，客户端 socket 已经进入 ESTABLISHED(TCP_ESTABLISHED) 状态。用 tcpdump 在 服务端 抓包，结果如下：

00:30:28.005237 IP 169.228.88.188.8888 > 169.228.88.168.52524: Flags [S.], seq 1093122830, ack 4065008943, win 65160, options [mss 1460,sackOK,TS val 3225418910 ecr 3875254422,nop,wscale 5], length 0

可以看到，服务端 169.228.88.188.8888 向 客户端 169.228.88.168.52524 回复了 一个 SACK 包(SYN + ACK)，服务端初始序号 为 y=1093122830，确认号 为 x+1=4065008943 。tcpdump 用 [S.] 标记 SACK 包。

3.1.4 服务端 接收 客户端 ACK，完成 三次握手

从上一小节 3.1.3 了解到，客户端 ==> 服务端 的 单边连接 已经建立，但 服务端 ==> 客户端 的 单边连接 尚未得到确认(即 服务端 还没有收取 客户端 对 SYN 的 ACK 回复)。下面来看 服务端 接收 客户端 ACK 完成 三次握手 的代码细节：

xxx_nic_interrput()
	...
	ip_rcv()
		tcp_v4_rcv()
			...
			const struct iphdr *iph;
 			const struct tcphdr *th;
 			...

			...
			th = (const struct tcphdr *)skb->data;
			iph = ip_hdr(skb);
		lookup:
			/* 
			 * !!! 
			 * 注意，这里查找到的 socket 对象，不再是 服务端 socket 套接字，
			 * 而是 服务端 收到 客户端 SYN 时 新建的、记录了 客户端连接信息
			 * 的 轻量 socket 对象 struct request_sock ，即 3.1.2 代码分
			 * 析注释中、 标记 (1) 处建立的 socket 对象。
			 */
			sk = __inet_lookup_skb(&tcp_hashinfo, skb, __tcp_hdrlen(th), th->source,
					th->dest, sdif, &refcounted);
			...

			if (sk->sk_state == TCP_NEW_SYN_RECV) {
				struct request_sock *req = inet_reqsk(sk); /* 服务端 记录 客户端连接信息的 轻量 socket */

				sk = req->rsk_listener; /* sk = 服务端 监听 socket */
				...
				if (!tcp_filter(sk, skb)) {
					th = (const struct tcphdr *)skb->data;
					iph = ip_hdr(skb);
					tcp_v4_fill_cb(skb, iph, th);
						/* TCP_SKB_CB(skb)->seq = x + 1; (x + 1 = 4065008942 + 1 = 4065008943)  */
						TCP_SKB_CB(skb)->seq = ntohl(th->seq);
						/* TCP_SKB_CB(skb)->ack_seq = y + 1; (y + 1 = 1093122830 + 1 = 1093122831) */
						TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
						...
						TCP_SKB_CB(skb)->tcp_flags = tcp_flag_byte(th); /* ACK */
						TCP_SKB_CB(skb)->tcp_tw_isn = 0;
						...
					...
				}
				...
			}

至此，客户端 <==> 服务端 的双向连接 已经建立完成。用 tcpdump 在 服务端 抓包，结果如下：

00:30:28.006550 IP 169.228.88.168.52524 > 169.228.88.188.8888: Flags [.], ack 1093122831, win 502, options [nop,nop,TS val 3875254506 ecr 3225418910], length 0

可以看到，服务端 169.228.88.188.8888 收到 客户端 169.228.88.168.52524 发送的 ACK，确认号 为 y+1 = 1093122831 。tcpdump 用 [.] 标识 ACK 。

3.1.5 三次握手期间的序号变化总结

下面描述中的 seq 表示 序号，ack_req 表示 确认号，flags 表示 TCP 协议头部标记(SYN,ACK 等)。

1. 客户端 向 服务端 发起 SYN 连接请求，SYN 包的 TCP 头部中: seq=x, ack_req=0, flags=SYN;
2. 服务端 收到 客户端 的 SYN 后，回复 客户端 SACK 包(SYN+ACK)，SACK 包的 TCP 头部中: seq=y, ack_req=x+1, flags=SYN|ACK;
3. 客户端 收到 的 SACK 后，回复 服务端 一个 ACK 包，ACK 包的 TCP 头部中：seq=x+1, ack_req=y+1 。

可以看到，通信两端(服务端 和 客户端)建立 初始序号 后，在 三次握手 期间，各自的 SYN 消耗了 1 个序号，最终，通信两端 的 序号 分别 停在了 x+1 和 y+1 上。

3.2 连接建立后，数据 通信 过程中 序号 的变化

在连接建立后，通信两端分别在当前序号 x+1 和 y+1 的基础上，每次以发送数据长度递增序号，发往对端数据的 确认号 为 接收到的对端数据中 序号 加 1。看一下 tcpdump 抓包情况：

00:30:57.585899 IP 169.228.88.168.52524 > 169.228.88.188.8888: Flags [P.], seq 4065008943:4065009967, ack 1093122831, win 502, options [nop,nop,TS val 3875284086 ecr 3225418910], length 1024
00:30:57.605209 IP 169.228.88.188.8888 > 169.228.88.168.52524: Flags [.], ack 4065009967, win 2005, options [nop,nop,TS val 3225448498 ecr 3875284086], length 0

可以看到，客户端 169.228.88.168.52524 向 服务端 169.228.88.188.8888 ，发送了 1024 个字节，数据 序号 位于 半开半闭 区间 [x+1=4065008943, x+1024=4065009967) (不包括 4065009967)；而 服务端 169.228.88.188.8888 确认收到 客户端 169.228.88.168.52524 的所有 1024 个字节后，回复 客户端 169.228.88.168.52524 一个 ACK，其 确认号为 x+1024=4065009967 。

3.3 四次挥手 连接断开 期间 序号 的变化

本文不对 四次挥手 期间 序号 的变化过程进行分析，感兴趣的读者可参考博文 Linux：TCP三握四挥简析，自行阅读源码分析。看一下 tcpdump 抓包情况：

00:30:57.605252 IP 169.228.88.168.52524 > 169.228.88.188.8888: Flags [F.], seq 4065009967, ack 1093122831, win 502, options [nop,nop,TS val 3875284086 ecr 3225418910], length 0
00:30:57.669707 IP 169.228.88.188.8888 > 169.228.88.168.52524: Flags [.], ack 4065009968, win 2005, options [nop,nop,TS val 3225448552 ecr 3875284086], length 0
00:31:02.468946 IP 169.228.88.188.8888 > 169.228.88.168.52524: Flags [F.], seq 1093122831, ack 4065009968, win 2005, options [nop,nop,TS val 3225453368 ecr 3875284086], length 0
00:31:02.469779 IP 169.228.88.168.52524 > 169.228.88.188.8888: Flags [.], ack 1093122832, win 502, options [nop,nop,TS val 3875288970 ecr 3225453368], length 0

可以看到：

1. `客户端 169.228.88.168.52524` 主动发起关闭(调用  `close()`)，向 `服务端 169.228.88.188.8888` 发送 `序号` 为 
   `x+1024=4065009967`、`确认号` 为 `y+1=1093122831`  的 `FIN` 包。`客户端` 发送了 1024 个字节后，再没有数据发送，
   所以 `FIN` 包 序号 紧接数据序号 之后；同时由于 `服务端` 没有 发送数据，所以 `确认号` 没有变化。
2. `服务端 169.228.88.188.8888` 回复 `客户端 169.228.88.168.52524` 的 `FIN` 包 一个 `ACK` ，`确认号` 为 
   `x+1024+1=4065009968`。至此，`客户端 到 服务端 的单向连接 已经断开`。
3. `服务端 169.228.88.188.8888` 向 `客户端 169.228.88.168.52524` 发送 FIN 包，请求断开连接，该包的 `序号` 为
   y+1=1093122831，确认号 为 `x+1024+1=4065009968`，因为 客户端 到 服务端 的单向连接 已经断开，不会再有从 客户端
   到 服务端 的数据，所以 确认号 不再变换。
4. `客户端 169.228.88.168.52524` 回复 `服务端 169.228.88.188.8888` 的 `FIN` 包 一个 `ACK` ，`确认号` 为 
   `y+1+1=1093122832`。至此，`服务端 到 客户端 的单向连接 已经断开`，于是整个连接彻底断开。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1318566.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

动态规划优化技巧

动态规划优化技巧

一、斐波那契系列 1、滚动数组优化空间复杂度 2、dp数组初始化/处理边界优化 力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台
阅读更多...
《Global illumination with radiance regression functions》

《Global illumination with radiance regression functions》

总结一下最近看的这篇结合神经网络的全局光照论文 这是一篇2013年TOG的论文。 介绍 论文的主要思想是利用了神经网络的非线性特性去拟合全局光照中的间接光照部分&#xff0c;采用了基础的2层MLP去训练&#xff0c;最终能实现一些点光源、glossy材质的光照渲染。为了更好的理…
阅读更多...
【POI的如何做大文件的写入】

【POI的如何做大文件的写入】

&#x1f513;POI如何做大文件的写入 &#x1f3c6;文件和POI之间的区别是什么&#xff1f;&#x1f3c6;POI对于当今的社会发展有何重要性&#xff1f;&#x1f3c6;POI大文件的写入&#x1f396;️使用XSSF写入文件&#x1f396;️使用SXSSFWorkbook写入文件&#x1f396;️对…
阅读更多...
《ThreadLocal使用与学习总结：2023-12-15》由浅入深全面解析ThreadLocal

《ThreadLocal使用与学习总结：2023-12-15》由浅入深全面解析ThreadLocal

由浅入深全面解析ThreadLocal 目录 由浅入深全面解析ThreadLocal简介基本使用ThreadLocal与synchronized的区别ThreadLocal现在的设计&#xff08;JDK1.8&#xff09;ThreadLocal核心方法源码分析ThreadLocalMap源码分析弱引用与内存泄露&#xff08;内存泄漏和弱引用没有直接关…
阅读更多...
代码随想录算法训练营第十四天 | 二叉树理论基础、递归遍历 、迭代遍历、统一迭代

代码随想录算法训练营第十四天 | 二叉树理论基础、递归遍历 、迭代遍历、统一迭代

今天学习内容&#xff1a;二叉树理论基础、递归遍历 、迭代遍历、统一迭代 讲解&#xff1a;代码随想录 二叉树题目思维导图如下&#xff0c;来自代码随想录。 1.二叉树理论基础 1.1二叉树种类 满二叉树 完全二叉树 二叉搜索树 平衡二叉搜索树 C中map、set、multimap&…
阅读更多...
[Verilog] Verilog 操作符与表达式

[Verilog] Verilog 操作符与表达式

主页&#xff1a; 元存储博客 文章目录 前言1. 操作符2. 操作数3 表达式总结 前言 1. 操作符 图片来源&#xff1a; https://www.runoob.com/ Verilog语言中使用的操作符包括&#xff1a; 算术操作符&#xff1a;加法()、减法(-)、乘法(*)、除法(/)、取模(%)、自增()、自减(–…
阅读更多...
Vue中插槽的使用

Vue中插槽的使用

目录 一、默认插槽 &#xff08;1&#xff09;概念 &#xff08;2&#xff09;代码展示 &#xff08;3&#xff09;后备内容 二、具名插槽 &#xff08;1&#xff09;概念 &#xff08;2&#xff09;代码展示 三、作用域插槽 &#xff08;1&#xff09;概念 &#xff0…
阅读更多...
【经典LeetCode算法题目专栏分类】【第2期】组合与排列问题系列

【经典LeetCode算法题目专栏分类】【第2期】组合与排列问题系列

《博主简介》 小伙伴们好&#xff0c;我是阿旭。专注于人工智能、AIGC、python、计算机视觉相关分享研究。 ✌更多学习资源&#xff0c;可关注公-仲-hao:【阿旭算法与机器学习】&#xff0c;共同学习交流~ &#x1f44d;感谢小伙伴们点赞、关注&#xff01; 组合总和1 class So…
阅读更多...
【计算机组成原理】存储系统基本概念与基本组成

【计算机组成原理】存储系统基本概念与基本组成

&#x1f4e2;&#xff1a;如果你也对机器人、人工智能感兴趣&#xff0c;看来我们志同道合✨ &#x1f4e2;&#xff1a;不妨浏览一下我的博客主页【https://blog.csdn.net/weixin_51244852】 &#x1f4e2;&#xff1a;文章若有幸对你有帮助&#xff0c;可点赞 &#x1f44d;…
阅读更多...
FRP内网映射家用服务器至公网访问

FRP内网映射家用服务器至公网访问

兄弟们&#xff0c;服务器到货了&#xff0c;后续与大家分享内容就用它了。我预装的操作系统是Centos8,首先要解决的是远程访问的问题。 【特别注意】下述的端口&#xff0c;记得在阿里云安全组配置中放开端口入规则&#xff01;&#xff01; 1. FRP服务器配置 之前我有购买…
阅读更多...
UDP多人聊天室

UDP多人聊天室

讲解的是TCP和UDP两种通信方式它们都有着自己的优点和缺点 这两种通讯方式不通的地方就是TCP是一对一通信 UDP是一对多的通信方式 UDP通信 主要的方向是一对多通信方式 UDP通信就是一下子可以通信多个对象&#xff0c;这就是UDP对比TCP的优势&#xff0c;UDP它的原理呢 就是…
阅读更多...
Spring之容器：IOC（1）

Spring之容器：IOC（1）

学习的最大理由是想摆脱平庸&#xff0c;早一天就多一份人生的精彩&#xff1b;迟一天就多一天平庸的困扰。各位小伙伴&#xff0c;如果您&#xff1a; 想系统/深入学习某技术知识点… 一个人摸索学习很难坚持&#xff0c;想组团高效学习… 想写博客但无从下手&#xff0c;急需…
阅读更多...
破译模式：模式识别在计算机视觉中的作用

破译模式：模式识别在计算机视觉中的作用

一、介绍 在当代数字领域&#xff0c;计算机视觉中的模式识别是关键的基石&#xff0c;推动着众多技术进步和应用。本文探讨了计算机视觉中模式识别的本质、方法、应用、挑战和未来趋势。通过使机器能够识别和解释视觉数据中的模式&#xff0c;模式识别不仅推动了计算机视觉领域…
阅读更多...
什么是回调函数

什么是回调函数

需求 A&#xff0c;B两个小组开发一个功能。B小组开发制作油条模块:make_youtiao。A小组需要调用B小组开发的模块&#xff0c;然后执行后续的操作&#xff1a;sell()如下图&#xff1a; 上面的方式A小组必须等待B小组开发的模块make_youtiao执行完成后才能执行sell()。 上图代…
阅读更多...
JVM-2-对象

JVM-2-对象

对象创建 当Java虚拟机遇到一条字节码new指令时&#xff0c;首先将去检查这个指令的参数是否能在常量池中定位到一个类的符号引用&#xff0c;并且检查这个符号引用代表的类是否已被加载、解析和初始化过。如果没有&#xff0c;那必须先执行相应的类加载过程。 为对象分配空间…
阅读更多...
linux性能优化-cpu使用率

linux性能优化-cpu使用率

文章目录 1.CPU使用率2.节拍率的概念2.1.查看系统节拍率2.2.用户节拍率2.3.CPU使用率公式 3.怎么查看CPU使用率3.1.top显示系统总体CPU使用情况3.2.pidstat分析每个进程CPU使用情况 4.CPU使用率过高怎么办4.1.perf命令详解 1.CPU使用率 用什么指标来描述系统的CPU性能呢?不是…
阅读更多...
SpringData JPA 整合Springboot

SpringData JPA 整合Springboot

1.导入依赖 <?xml version"1.0" encoding"UTF-8"?> <project xmlns"http://maven.apache.org/POM/4.0.0"xmlns:xsi"http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation"http://maven.apache.org/POM/4.0…
阅读更多...
Oracle 透明网关安装

Oracle 透明网关安装

Oracle 11g透明网关连接Sqlserver oracle 透明网关是oracle连接异构数据库提供的一种技术。通过Gateway&#xff0c;可以在Oracle里透明的访问其他不同的数据库&#xff0c;如SQL Server, DB2, Sybase等等&#xff0c;就像远程Oracle数据库一样。配置后的sql查询的处理流程&…
阅读更多...
架构设计系列之基础设施能力建设

架构设计系列之基础设施能力建设

周末聊两句&#xff1a; 今天将的基础设施能力建设部分&#xff0c;一般的架构书籍中都不存在的部分&#xff0c;这是我在实践过程中的经验和能力总结部分&#xff0c;希望和大家有一个很好的交流自从在 WeChat 中开了订阅号的两周半的时间&#xff0c;非常感谢大家的支持&…
阅读更多...
Spring Boot 3 整合 Hutool 验证码实战

Spring Boot 3 整合 Hutool 验证码实战

&#x1f680; 作者主页&#xff1a; 有来技术 &#x1f525; 开源项目&#xff1a; youlai-mall &#x1f343; vue3-element-admin &#x1f343; youlai-boot &#x1f33a; 仓库主页&#xff1a; Gitee &#x1f4ab; Github &#x1f4ab; GitCode &#x1f496; 欢迎点赞…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023