Wireshark分析报文
对TCP三次握手过程进行抓包分析，并通过Wireshark的Analyze分析出tcp握手过程，通过截图体现传输内容。
1、捕获大量的由本地主机到远程服务器的TCP分组；
2、浏览追踪信息
在显示筛选规则编辑框中输入“tcp”,可以看到在本地主机和服务器之间传输的一系列tcp和HTTP消息，你应该能看到包含SYN Segment的三次握手。通过Analyze的Follow TCP Stream分析出传输内容。写出其中某TCP数据包的源IP地址，目的IP地址，源端口，目的端口，窗口大小。
筛选：
分析某一条数据包：
那么：
源IP地址：172.16.72.229
目的IP地址：36.110.171.40
源端口：51859
目的端口：80
窗口大小：8192
TCP的三次握手
TCP的三次握手大家都不陌生，下面用wireshark这个工具抓包，进一步的说明三次握手的细节。
1.由客户端发起tcp连接的请求，此时客户端发送一条报文，其中包含SYN标志位，将SYN设置为1； 以及seq位。设seq = x ; 该报文段成为SYN报文段
2.服务器收到这条报文后，返回给客户端一条报文，包含Ack位,SYN,以及seq位。 其中ack = x+1; SYN = 1; seq = y。该报文段称为SYNACK报文段
3.当客户端收到SYNACK报文段之后，客户端需要再给服务器发送另外一个报文段，进行确认。该报文段的SYN = 0, seq = x +１， ack = y+1;
TCP协议源代码跟踪分析
1.TCP的三次握手从用户程序的角度看就是客户端connect和服务端accept建立起连接时背后的完成的工作。由上次的实验我们可以知道，在socket接口层这两个socket API函数分别对应着sys_connect和sys_accept4函数，课上老师说明， sys_connect和sys_accecpt是通过函数指针sock->opt->connect和sock->opt->accept调用了具体的函数来实现的，在即调用了tcp_v4_connect函数和inet_csk_accept函数，这两个函数进一步触及TCP数据收发过程tcp_transmit_skb和tcp_v4_rcv函数。
在net/ipv4/tcp-ipv4.c文件下的结构体变量struct proto tcp_prot指定了TCP协议栈的访问接口函数：
1 struct proto tcp_prot = {
2 .name = "TCP",
3 .owner = THIS_MODULE,
4 .close = tcp_close,
5 .pre_connect = tcp_v4_pre_connect,
6 .connect = tcp_v4_connect,
7 .disconnect = tcp_disconnect,
8 .accept = inet_csk_accept,
9 .ioctl = tcp_ioctl,
10 .init = tcp_v4_init_sock,
11 .destroy = tcp_v4_destroy_sock,
12 .shutdown = tcp_shutdown,
13 .setsockopt = tcp_setsockopt,
14 .getsockopt = tcp_getsockopt,
15 .keepalive = tcp_set_keepalive,
16 .recvmsg = tcp_recvmsg,
17 .sendmsg = tcp_sendmsg,
18 .sendpage = tcp_sendpage,
19 .backlog_rcv = tcp_v4_do_rcv,
20 .release_cb = tcp_release_cb,
21 .hash = inet_hash,
22 .unhash = inet_unhash,
23 .get_port = inet_csk_get_port,
24 .enter_memory_pressure = tcp_enter_memory_pressure,
25 .leave_memory_pressure = tcp_leave_memory_pressure,
26 .stream_memory_free = tcp_stream_memory_free,
27 .sockets_allocated = &tcp_sockets_allocated,
28 .orphan_count = &tcp_orphan_count,
29 .memory_allocated = &tcp_memory_allocated,
30 .memory_pressure = &tcp_memory_pressure,
31 .sysctl_mem = sysctl_tcp_mem,
32 .sysctl_wmem_offset = offsetof(struct net, ipv4.sysctl_tcp_wmem),
33 .sysctl_rmem_offset = offsetof(struct net, ipv4.sysctl_tcp_rmem),
34 .max_header = MAX_TCP_HEADER,
35 .obj_size = sizeof(struct tcp_sock),
36 .slab_flags = SLAB_TYPESAFE_BY_RCU,
37 .twsk_prot = &tcp_timewait_sock_ops,
38 .rsk_prot = &tcp_request_sock_ops,
39 .h.hashinfo = &tcp_hashinfo,
40 .no_autobind = true,
41 #ifdef CONFIG_COMPAT
42 .compat_setsockopt = compat_tcp_setsockopt,
43 .compat_getsockopt = compat_tcp_getsockopt,
44 #endif
45 .diag_destroy = tcp_abort,
46 };
在这里，我们可以看到socket接口层里sock->opt->connect和sock->opt->accept实际调用的函数tcp_v4_connect和inet_csk_accept。
2.接下来通过MenuOS的内核调试环境设置断点跟踪tcp_v4_connect函数和inet_csk_accept函数来进一步验证三次握手的过程。
在tcp_v4_connect处打个断点：
可以发现tcp_v4_connect函数在net/ipv4/tcp_ipv4.c处定义，看下代码：
1 /* This will initiate an outgoing connection. */
2 int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
3 {
4 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
5 struct inet_sock *inet = inet_sk(sk);
6 struct tcp_sock *tp = tcp_sk(sk);
7 __be16 orig_sport, orig_dport;
8 __be32 daddr, nexthop;
9 struct flowi4 *fl4;
10 struct rtable *rt;
11 int err;
12 struct ip_options_rcu *inet_opt;
13 struct inet_timewait_death_row *tcp_death_row = &sock_net(sk)->ipv4.tcp_death_row;
14
15
16 if (addr_len < sizeof(struct sockaddr_in))
17 return -EINVAL;
18
19
20 if (usin->sin_family != AF_INET)
21 return -EAFNOSUPPORT;
22
23
24 nexthop = daddr = usin->sin_addr.s_addr;
25 inet_opt = rcu_dereference_protected(inet->inet_opt,
26 lockdep_sock_is_held(sk));
27 if (inet_opt && inet_opt->opt.srr) {
28 if (!daddr)
29 return -EINVAL;
30 nexthop = inet_opt->opt.faddr;
31 }
32
33
34 orig_sport = inet->inet_sport;
35 orig_dport = usin->sin_port;
36 fl4 = &inet->cork.fl.u.ip4;
37 rt = ip_route_connect(fl4, nexthop, inet->inet_saddr,
38 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
39 IPPROTO_TCP,
40 orig_sport, orig_dport, sk);
41 if (IS_ERR(rt)) {
42 err = PTR_ERR(rt);
43 if (err == -ENETUNREACH)
44 IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTNOROUTES);
45 return err;
46 }
47
48
49 if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
50 ip_rt_put(rt);
51 return -ENETUNREACH;
52 }
53
54
55 if (!inet_opt || !inet_opt->opt.srr)
56 daddr = fl4->daddr;
57
58
59 if (!inet->inet_saddr)
60 inet->inet_saddr = fl4->saddr;
61 sk_rcv_saddr_set(sk, inet->inet_saddr);
62
63
64 if (tp->rx_opt.ts_recent_stamp && inet->inet_daddr != daddr) {
65 /* Reset inherited state */
66 tp->rx_opt.ts_recent = 0;
67 tp->rx_opt.ts_recent_stamp = 0;
68 if (likely(!tp->repair))
69 tp->write_seq = 0;
70 }
71
72
73 inet->inet_dport = usin->sin_port;
74 sk_daddr_set(sk, daddr);
75
76
77 inet_csk(sk)->icsk_ext_hdr_len = 0;
78 if (inet_opt)
79 inet_csk(sk)->icsk_ext_hdr_len = inet_opt->opt.optlen;
80
81
82 tp->rx_opt.mss_clamp = TCP_MSS_DEFAULT;
83
84
85 /* Socket identity is still unknown (sport may be zero).
86 * However we set state to SYN-SENT and not releasing socket
87 * lock select source port, enter ourselves into the hash tables and
88 * complete initialization after this.
89 */
90 tcp_set_state(sk, TCP_SYN_SENT);
91 err = inet_hash_connect(tcp_death_row, sk);
92 if (err)
93 goto failure;
94
95
96 sk_set_txhash(sk);
97
98
99 rt = ip_route_newports(fl4, rt, orig_sport, orig_dport,
100 inet->inet_sport, inet->inet_dport, sk);
101 if (IS_ERR(rt)) {
102 err = PTR_ERR(rt);
103 rt = NULL;
104 goto failure;
105 }
106 /* OK, now commit destination to socket. */
107 sk->sk_gso_type = SKB_GSO_TCPV4;
108 sk_setup_caps(sk, &rt->dst);
109 rt = NULL;
110
111
112 if (likely(!tp->repair)) {
113 if (!tp->write_seq)
114 tp->write_seq = secure_tcp_seq(inet->inet_saddr,
115 inet->inet_daddr,
116 inet->inet_sport,
117 usin->sin_port);
118 tp->tsoffset = secure_tcp_ts_off(sock_net(sk),
119 inet->inet_saddr,
120 inet->inet_daddr);
121 }
122
123
124 inet->inet_id = tp->write_seq ^ jiffies;
125
126
127 if (tcp_fastopen_defer_connect(sk, &err))
128 return err;
129 if (err)
130 goto failure;
131
132
133 err = tcp_connect(sk);
134
135
136 if (err)
137 goto failure;
138
139
140 return 0;
141
142
143 failure:
144 /*
145 * This unhashes the socket and releases the local port,
146 * if necessary.
147 */
148 tcp_set_state(sk, TCP_CLOSE);
149 ip_rt_put(rt);
150 sk->sk_route_caps = 0;
151 inet->inet_dport = 0;
152 return err;
153 }
分析代码，可以看出tcp_v4_connect函数的主要作用就是发起一个TCP连接，从这个函数中可以看到它调用了IP层提供的一些服务，比如ip_route_connect和ip_route_newports，同时在tcp_v4_connect函数中，调用了tcp_set_state函数，它设置了TCP_SYN_SENT，并进一步调用了tcp_connect(sk)来实际构造SYN并发送出去。
tcp_connect函数具体负责构造一个携带SYN标志位的TCP头并发送出去，同时还设置了计时器超时重发。这个函数定义在net/ipv4/tcp_output.c文件中，看看代码：
1 /* Build a SYN and send it off. */
2 int tcp_connect(struct sock *sk)
3 {
4 struct tcp_sock *tp = tcp_sk(sk);
5 struct sk_buff *buff;
6 int err;
7
8
9 tcp_call_bpf(sk, BPF_SOCK_OPS_TCP_CONNECT_CB, 0, NULL);
10
11
12 if (inet_csk(sk)->icsk_af_ops->rebuild_header(sk))
13 return -EHOSTUNREACH; /* Routing failure or similar. */
14
15
16 tcp_connect_init(sk);
17
18
19 if (unlikely(tp->repair)) {
20 tcp_finish_connect(sk, NULL);
21 return 0;
22 }
23
24
25 buff = sk_stream_alloc_skb(sk, 0, sk->sk_allocation, true);
26 if (unlikely(!buff))
27 return -ENOBUFS;
28
29
30 tcp_init_nondata_skb(buff, tp->write_seq++, TCPHDR_SYN);
31 tcp_mstamp_refresh(tp);
32 tp->retrans_stamp = tcp_time_stamp(tp);
33 tcp_connect_queue_skb(sk, buff);
34 tcp_ecn_send_syn(sk, buff);
35 tcp_rbtree_insert(&sk->tcp_rtx_queue, buff);
36
37
38 /* Send off SYN; include data in Fast Open. */
39 err = tp->fastopen_req ? tcp_send_syn_data(sk, buff) :
40 tcp_transmit_skb(sk, buff, 1, sk->sk_allocation);
41 if (err == -ECONNREFUSED)
42 return err;
43
44
45 /* We change tp->snd_nxt after the tcp_transmit_skb() call
46 * in order to make this packet get counted in tcpOutSegs.
47 */
48 tp->snd_nxt = tp->write_seq;
49 tp->pushed_seq = tp->write_seq;
50 buff = tcp_send_head(sk);
51 if (unlikely(buff)) {
52 tp->snd_nxt = TCP_SKB_CB(buff)->seq;
53 tp->pushed_seq = TCP_SKB_CB(buff)->seq;
54 }
55 TCP_INC_STATS(sock_net(sk), TCP_MIB_ACTIVEOPENS);
56
57
58 /* Timer for repeating the SYN until an answer. */
59 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
60 inet_csk(sk)->icsk_rto, TCP_RTO_MAX);
61 return 0;
62 }
63 EXPORT_SYMBOL(tcp_connect);
其中tcp_transmit_skb函数将tcp数据发送出去。
这边，客户端的一个tcp数据包发送出去了，服务端将做出什么反应呢，下面来看看服务端的inet_csk_accept函数，首先在inet_csk_accept处打上断点：
inet_csk_accept函数在net/ipv4/inet_connection_sock.c文件中：
1 /*
2 * This will accept the next outstanding connection.
3 */
4 struct sock *inet_csk_accept(struct sock *sk, int flags, int *err, bool kern)
5 {
6 struct inet_connection_sock *icsk = inet_csk(sk);
7 struct request_sock_queue *queue = &icsk->icsk_accept_queue;
8 struct request_sock *req;
9 struct sock *newsk;
10 int error;
11
12
13 lock_sock(sk);
14
15
16 /* We need to make sure that this socket is listening,
17 * and that it has something pending.
18 */
19 error = -EINVAL;
20 if (sk->sk_state != TCP_LISTEN)
21 goto out_err;
22
23
24 /* Find already established connection */
25 if (reqsk_queue_empty(queue)) {
26 long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
27
28
29 /* If this is a non blocking socket don‘t sleep */
30 error = -EAGAIN;
31 if (!timeo)
32 goto out_err;
33
34
35 error = inet_csk_wait_for_connect(sk, timeo);
36 if (error)
37 goto out_err;
38 }
39 req = reqsk_queue_remove(queue, sk);
40 newsk = req->sk;
41
42
43 if (sk->sk_protocol == IPPROTO_TCP &&
44 tcp_rsk(req)->tfo_listener) {
45 spin_lock_bh(&queue->fastopenq.lock);
46 if (tcp_rsk(req)->tfo_listener) {
47 /* We are still waiting for the final ACK from 3WHS
48 * so can‘t free req now. Instead, we set req->sk to
49 * NULL to signify that the child socket is taken
50 * so reqsk_fastopen_remove() will free the req
51 * when 3WHS finishes (or is aborted).
52 */
53 req->sk = NULL;
54 req = NULL;
55 }
56 spin_unlock_bh(&queue->fastopenq.lock);
57 }
58 out:
59 release_sock(sk);
60 if (req)
61 reqsk_put(req);
62 return newsk;
63 out_err:
64 newsk = NULL;
65 req = NULL;
66 *err = error;
67 goto out;
68 }
69 EXPORT_SYMBOL(inet_csk_accept);
服务端的inet_csk_accept函数会从请求队列中取出一个连接请求，如果队列为空则通过inet_csk_wait_for_connect阻塞住等待客户端的连接。
inet_csk_wait_for_connect函数定义在net/ipv4/inet_connection_sock.c文件中：
1 static int inet_csk_wait_for_connect(struct sock *sk, long timeo)
2 {
3 struct inet_connection_sock *icsk = inet_csk(sk);
4 DEFINE_WAIT(wait);
5 int err;
6 for (;;) {
7 prepare_to_wait_exclusive(sk_sleep(sk), &wait,
8 TASK_INTERRUPTIBLE);
9 release_sock(sk);
10 if (reqsk_queue_empty(&icsk->icsk_accept_queue))
11 timeo = schedule_timeout(timeo);
12 sched_annotate_sleep();
13 lock_sock(sk);
14 err = 0;
15 if (!reqsk_queue_empty(&icsk->icsk_accept_queue))
16 break;
17 err = -EINVAL;
18 if (sk->sk_state != TCP_LISTEN)
19 break;
20 err = sock_intr_errno(timeo);
21 if (signal_pending(current))
22 break;
23 err = -EAGAIN;
24 if (!timeo)
25 break;
26 }
27 finish_wait(sk_sleep(sk), &wait);
28 return err;
29 }
根据代码可以分析出整个三次握手的过程为：客户端通过tcp_v4_connect函数调用到tcp_connect函数，将请求发送数据包出去，服务器端则通过inet_csk_accept函数调用inet_csk_wait_for_connect函数中的for循环进入阻塞，直到监听到请求才跳出循环。connect启动到返回和accept返回之间就是所谓三次握手的时间。
3.三次握手中携带SYN/ACK的TCP头数据的发送和接收
以上分析了用户程序调用socket接口、通过系统调用陷入内核进入内核态的socket接口层代码，然后根据创建socket时指定协议选择适当的函数指针进入协议处理代码中。那么网卡接收到数据后是如何通知上层协议来接收并处理数据的呢。其实在TCP/IP协议栈的初始化过程中，协议栈将handler赋值为tcp_v4_rcv的函数指针，也就是TCP协议中负责接收处理数据的入口，接收TCP连接请求及进行三次握手处理过程也都是从这里开始。
内核在处理接收到的TCP报文时使用了4个队列容器，分别为receive、out_of_order、prequeue、backlog队列。当网卡接收到报文并判断为TCP协议后，将会调用到内核的tcp_v4_rcv方法。tcp_v4_rcv方法会把这个报文直接插入到receive队列中。
在该函数定义在net/ipv4/tcp_ipv4.c文件中。
tcp_v4_rcv函数只要做以下几个工作：
(1) 设置TCP_CB
(2) 查找控制块
(3)根据控制块状态做不同处理，包括TCP_TIME_WAIT状态处理，TCP_NEW_SYN_RECV状态处理，TCP_LISTEN状态处理
(4) 接收TCP段
以上完成了将接收数据放入accept队列中，之后服务端接收客户端发来的tcp报文，并发送回SYN+ACK。
当前客户端处于TCP_SYN_SENT状态，并调用tcp_rcv_synsent_state_process处理SYN_SENT状态下接收到的TCP段，发送ACK报文
到这里，三次握手期间tcp接收处理数据包的过程基本完成。
原文地址：https://www.cnblogs.com/maotx/p/12102521.html