关于TCP协议
TCP/IP协议分层模型
可以看到，TCP协议位于运输层，TCP将用户数据打包构成报文段，它发送数据时启动一个定时器，另一端收到数据进行确认，对失序的数据重新排序，丢弃重复的数据。TCP提供一种面向连接的可靠的字节流服务，面向连接意味着两个使用TCP的应用（B/S）在彼此交换数据之前，必须先建立一个TCP连接，类似于打电话过程，先拨号振铃，等待对方说喂，然后应答。在一个TCP连接中，只有两方彼此通信。
TCP可靠性来自于：
（1）应用数据被分成TCP最合适的发送数据块
（2）当TCP发送一个段之后，启动一个定时器，等待目的点确认收到报文，如果不能及时收到一个确认，将重发这个报文。
（3）当TCP收到连接端发来的数据，就会推迟几分之一秒发送一个确认。
（4）TCP将保持它首部和数据的检验和，这是一个端对端的检验和，目的在于检测数据在传输过程中是否发生变化。（有错误，就不确认，发送端就会重发）
（5）TCP是以IP报文来传送，IP数据是无序的，TCP收到所有数据后进行排序，再交给应用层
（6）IP数据报会重复，所以TCP会去重
（7）TCP能提供流量控制，TCP连接的每一个地方都有固定的缓冲空间。TCP的接收端只允许另一端发送缓存区能接纳的数据。
（8）TCP对字节流不做任何解释，对字节流的解释由TCP连接的双方应用层解释。
TCP建立连接的过程（三次握手）
TCP是一个面向连接的协议，无论哪一方向另一方发送数据之前，都必须先在双方之间建立一条连接，所谓三次握手（Three-Way Handshake）即建立TCP连接，就是指建立一个TCP连接时，需要客户端和服务端总共发送3个包以确认连接的建立。在socket编程中，这一过程由客户端执行connect来触发，整个流程如下图所示：
（1）第一次握手：Client将标志位SYN置为1，随机产生一个值seq=J，并将该数据包发送给Server，Client进入SYN_SENT状态，等待Server确认。
（2）第二次握手：Server收到数据包后由标志位SYN=1知道Client请求建立连接，Server将标志位SYN和ACK都置为1，ack=J+1，随机产生一个值seq=K，并将该数据包发送给Client以确认连接请求，Server进入SYN_RCVD状态。
（3）第三次握手：Client收到确认后，检查ack是否为J+1，ACK是否为1，如果正确则将标志位ACK置为1，ack=K+1，并将该数据包发送给Server，Server检查ack是否为K+1，ACK是否为1，如果正确则连接建立成功，Client和Server进入ESTABLISHED状态，完成三次握手，随后Client与Server之间可以开始传输数据了。
简单来说，就是：
1、建立连接时，客户端发送SYN包（SYN=i）到服务器，并进入到SYN-SEND状态，等待服务器确认；
2、服务器收到SYN包，必须确认客户的SYN（ack=i+1）,同时自己也发送一个SYN包（SYN=k）,即SYN+ACK包，此时服务器进入SYN-RECV状态；
3、客户端收到服务器的SYN+ACK包，向服务器发送确认报ACK（ack=k+1）,此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手，客户端与服务器开始传送数据。
关于SYN泛洪攻击
在三次握手过程中，Server发送SYN-ACK之后，收到Client的ACK之前的TCP连接称为半连接（half-open connect），此时Server处于SYN_RCVD状态，当收到ACK后，Server转入ESTABLISHED状态。SYN攻击就是Client在短时间内伪造大量不存在的IP地址，并向Server不断地发送SYN包，Server回复确认包，并等待Client的确认，由于源地址是不存在的，因此，Server需要不断重发直至超时，这些伪造的SYN包将产时间占用未连接队列，导致正常的SYN请求因为队列满而被丢弃，从而引起网络堵塞甚至系统瘫痪。SYN攻击时一种典型的DDOS攻击，检测SYN攻击的方式非常简单，即当Server上有大量半连接状态且源IP地址是随机的，则可以断定遭到SYN攻击了，使用如下命令可以让之现行：
netstat -nap | grep SYN_RECV
谈了TCP协议连接建立的三次握手后，接下来再复习下linux socket协议栈的相关内容：
关于linux socket
linux网络路径
从上图中可以清晰地看到socket在网络分层中的位置，由于socket接口应该划在应用层，而我们日常的网络编程也都基本在应用层上，所以下面将从发送端和接收端两个角度分别对应用层进行分析：
发送端
应用层
（1） Socket
应用层的各种网络应用程序基本上都是通过 Linux Socket 编程接口来和内核空间的网络协议栈通信的。Linux Socket 是从 BSD Socket 发展而来的，它是 Linux 操作系统的重要组成部分之一，它是网络应用程序的基础。从层次上来说，它位于应用层，是操作系统为应用程序员提供的 API，通过它，应用程序可以访问传输层协议。
- socket 位于传输层协议之上，屏蔽了不同网络协议之间的差异
- socket 是网络编程的入口，它提供了大量的系统调用，构成了网络程序的主体
- 在Linux系统中，socket 属于文件系统的一部分，网络通信可以被看作是对文件的读取，使得我们对网络的控制和对文件的控制一样方便。
TCP Socket 处理过程
（2） 应用层处理流程
- 网络应用调用Socket API socket (int family, int type, int protocol) 创建一个 socket，该调用最终会调用 Linux system call socket() ，并最终调用 Linux Kernel 的 sock_create() 方法。该方法返回被创建好了的那个 socket 的 file descriptor。对于每一个 userspace 网络应用创建的 socket，在内核中都有一个对应的 struct socket和 struct sock。其中，struct sock 有三个队列（queue），分别是 rx , tx 和 err，在 sock 结构被初始化的时候，这些缓冲队列也被初始化完成；在收据收发过程中，每个 queue 中保存要发送或者接受的每个 packet 对应的 Linux 网络栈 sk_buffer 数据结构的实例 skb。
- 对于 TCP socket 来说，应用调用 connect（）API ，使得客户端和服务器端通过该 socket 建立一个虚拟连接。在此过程中，TCP 协议栈通过三次握手会建立 TCP 连接。默认地，该 API 会等到 TCP 握手完成连接建立后才返回。在建立连接的过程中的一个重要步骤是，确定双方使用的 Maxium Segemet Size （MSS）。
- 应用调用 Linux Socket 的 send 或者 write API 来发出一个 message 给接收端
- sock_sendmsg 被调用，它使用 socket descriptor 获取 sock struct，创建 message header 和 socket control message
- _sock_sendmsg 被调用，根据 socket 的协议类型，调用相应协议的发送函数。
对于 TCP ，调用 tcp_sendmsg 函数。
接收端
应用层
- 每当用户应用调用 read 或者 recvfrom 时，该调用会被映射为/net/socket.c 中的 sys_recv 系统调用，并被转化为 sys_recvfrom 调用，然后调用 sock_recgmsg 函数。
- 对于 INET 类型的 socket，/net/ipv4/af inet.c 中的 inet_recvmsg 方法会被调用，它会调用相关协议的数据接收方法。
- 对 TCP 来说，调用 tcp_recvmsg。该函数从 socket buffer 中拷贝数据到 user buffer。
TCP相关源码深度分析及GDB跟踪调试
虚拟机：ubuntu 16.04
内核版本：linux 5.0.1
编译方式：x86-64
模拟器：qemu
基于系统：部署好TCP通信程序的Menu OS系统
相关目录路径：/net/ipv4、/net/socket.c
TCP相关系统接口定义
再次跑起来之前已经部署好TCP通信程序的Menu OS系统，追踪与TCP连接相关的socket、connect、listen、accept函数的系统调用：
首先以调试模式运行Menu OS系统：
cd kernel qemu-system-x86_64 -kernel linux-5.0.1/arch/x86/boot/bzImage -initrd rootfs.img -append nokaslr -s
新打开一个命令行运行GDB进行Menu OS的调试：
cd kernel file linux-5.0.1/vmlinux target remote:1234
设置相应的断点：
b __sys_socket b __sys_connect b __sys_listen b __sys_accept4 info breakpoints
发现相应的socket系统调用函数都在 net/socket.c目录下，打开该目录，分析源代码，其中socket接口函数都定义在SYSCALL_DEFINE接口里，找到主要的相关SYSCALL_DEFINE定义如下：
1 SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol)
2 {
3 return __sys_socket(family, type, protocol);
4 }
5
6 SYSCALL_DEFINE3(bind, int, fd, struct sockaddr __user *, umyaddr, int, addrlen)
7 {
8 return __sys_bind(fd, umyaddr, addrlen);
9 }
10
11 SYSCALL_DEFINE2(listen, int, fd, int, backlog)
12 {
13 return __sys_listen(fd, backlog);
14 }
15
16
17 SYSCALL_DEFINE3(accept, int, fd, struct sockaddr __user *, upeer_sockaddr,
18 int __user *, upeer_addrlen)
19 {
20 return __sys_accept4(fd, upeer_sockaddr, upeer_addrlen, 0);
21 }
22
23 SYSCALL_DEFINE3(connect, int, fd, struct sockaddr __user *, uservaddr,
24 int, addrlen)
25 {
26 return __sys_connect(fd, uservaddr, addrlen);
27 }
28
29 SYSCALL_DEFINE3(getsockname, int, fd, struct sockaddr __user *, usockaddr,
30 int __user *, usockaddr_len)
31 {
32 return __sys_getsockname(fd, usockaddr, usockaddr_len);
33 }
34
35 SYSCALL_DEFINE3(getpeername, int, fd, struct sockaddr __user *, usockaddr,
36 int __user *, usockaddr_len)
37 {
38 return __sys_getpeername(fd, usockaddr, usockaddr_len);
39 }
40
41
42 SYSCALL_DEFINE4(send, int, fd, void __user *, buff, size_t, len,
43 unsigned int, flags)
44 {
45 return __sys_sendto(fd, buff, len, flags, NULL, 0);
46 }
47
48 SYSCALL_DEFINE4(recv, int, fd, void __user *, ubuf, size_t, size,
49 unsigned int, flags)
50 {
51 return __sys_recvfrom(fd, ubuf, size, flags, NULL, NULL);
52 }
逐步分析TCP三次握手的系统级实现
TCP连接前的初始化过程
1）调用__sys_socket, __sys_socket源码如下：
int __sys_socket(int family, int type, int protocol)
{
int retval;
struct socket *sock;
int flags;
/* Check the SOCK_* constants for consistency. */
BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC);
BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK);
BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK);
BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK);
flags = type & ~SOCK_TYPE_MASK;
if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
return -EINVAL;
type &= SOCK_TYPE_MASK;
if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
retval = sock_create(family, type, protocol, &sock);
if (retval < 0)
return retval;
return sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK));
}
可以看到，__sys_socket调用了sock_create和sock_map_fd函数；
2）调用sock_create()：创建socket结构，针对每种不同的family的socket结构的初始化，就需要调用不同的create函数来完成。对应于inet类型的地址来说，在网络协议初始化时调用sock_register()函数中完成注册的定义如下：
struct net_proto_family inet_family_ops={
PF_INET;
inet_create
};
所以inet协议最后会调用inet_create函数。
3）调用inet_create: 初始化sock的状态设置为SS_UNCONNECTED,申请一个新的sock结构，并且初始化socket的成员ops初始化为inet_stream_ops,而sock的成员prot初始化为tcp_prot。然后调用sock_init_data,将该socket结构的变量sock和sock类型的变量关联起来。
inet_create函数源码如下：
1 static int inet_create(struct net *net, struct socket *sock, int protocol,int kern)
2 {
3 ...
4 /* Look for the requested type/protocol pair. */
5 lookup_protocol:
6 err = -ESOCKTNOSUPPORT;
7 rcu_read_lock();
8
9 // TCP套接字、UDP套接字、原始套接字的inet_protosw实 例都在inetsw_array数组中定义，
10 //这些实例会调inet_register_protosw()注册到inetsw中
11 //根据protocol查找要创建的套接字对应的四层传输协议。
12 list_for_each_entry_rcu(answer, &inetsw[sock->type], list) {
13 ...
14 }
15
16 //如果没有找到，则调用request_module()来尝试加载协议所属的模块，正常情况下不会发生。
17 if (unlikely(err)) {
18 if (try_loading_module < 2) {
19 rcu_read_unlock();
20 ...
21 }
4）调用sock_map_fd()获取一个未被使用的文件描述符，并且申请并初始化对应的file{}结构。
TCP连接的三次握手过程深度解析
接下来通过阅读TCP源代码的方式，一步步地追踪解析系统级TCP三次握手的详细过程。首先从__sys_connect源码开始，逐步向深处探究：
1 int __sys_connect(int fd, struct sockaddr __user *uservaddr, int addrlen)
2 {
3 struct socket *sock;
4 struct sockaddr_storage address;
5 int err, fput_needed;
6 //得到socket对象
7 sock = sockfd_lookup_light(fd, &err, &fput_needed);
8 if (!sock)
9 goto out;
10 //将地址对象从用户空间拷贝到内核空间
11 err = move_addr_to_kernel(uservaddr, addrlen, &address);
12 if (err < 0)
13 goto out_put;
14 //内核相关
15 err =
16 security_socket_connect(sock, (struct sockaddr *)&address, addrlen);
17 if (err)
18 goto out_put;
19 //对于流式套接字,sock->ops为 inet_stream_ops -->inet_stream_connect
20
21 //对于数据报套接字,sock->ops为 inet_dgram_ops --> inet_dgram_connect
22 err = sock->ops->connect(sock, (struct sockaddr *)&address, addrlen,
23 sock->file->f_flags);
24 out_put:
25 fput_light(sock->file, fput_needed);
26 out:
27 return err;
28 }
在该函数中做了三件事：
1. 根据文件描述符找到指定的socket对象；
2. 将地址信息从用户空间拷贝到内核空间；
3. 调用指定类型套接字的connect函数。
对应流式套接字的connect函数是inet_stream_connect，接着我们分析该函数：
在GDB中设置断点找到源文件：
1 int inet_stream_connect(struct socket *sock, struct sockaddr *uaddr,
2 int addr_len, int flags)
3 {
4 int err;
5
6 lock_sock(sock->sk);
7 err = __inet_stream_connect(sock, uaddr, addr_len, flags);
8 release_sock(sock->sk);
9 return err;
10 }
11
12 /*
13 * Connect to a remote host. There is regrettably still a little
14 * TCP 'magic' in here.
15 */
16
17 //1. 检查socket地址长度和使用的协议族。
18 //2. 检查socket的状态，必须是SS_UNCONNECTED或SS_CONNECTING。
19 //3. 调用tcp_v4_connect()来发送SYN包。
20 //4. 等待后续握手的完成：
21 int __inet_stream_connect(struct socket *sock, struct sockaddr *uaddr,
22 int addr_len, int flags)
23 ...
24 后面太多便不再展示，可直接看源码
该函数主要做了几件事：
1. 检查socket地址长度和使用的协议族；
2. 检查socket的状态，必须是SS_UNCONNECTED或SS_CONNECTING；
3. 调用实现协议的connect函数，对于流式套接字，实现协议是tcp，调用的是tcp_v4_connect()；
4.对于阻塞调用，等待后续握手的完成；对于非阻塞调用，则直接返回 -EINPROGRESS。
我们先关注tcp_v4_connect，同样先在gdb中设置断点，找到源文件所在位置：
1 /* This will initiate an outgoing connection. */
2
3 //对于TCP 协议来说，其连接实际上就是发送一个 SYN 报文，在服务器的应答到来时，回答它一个 ack 报文，也就是完成三次握手中的第一和第三次
4 int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
5 {
6 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
7 struct inet_sock *inet = inet_sk(sk);
8 struct tcp_sock *tp = tcp_sk(sk);
9 __be16 orig_sport, orig_dport;
10 __be32 daddr, nexthop;
11 struct flowi4 *fl4;
12 struct rtable *rt;
13 int err;
14 struct ip_options_rcu *inet_opt;
15
16 if (addr_len < sizeof(struct sockaddr_in))
17 return -EINVAL;
18
19 if (usin->sin_family != AF_INET)
20 return -EAFNOSUPPORT;
21
22 nexthop = daddr = usin->sin_addr.s_addr;
23 inet_opt = rcu_dereference_protected(inet->inet_opt,
24 lockdep_sock_is_held(sk));
25
26 //将下一跳地址和目的地址的临时变量都暂时设为用户提交的地址。
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
36 //目的端口
37 orig_dport = usin->sin_port;
38
39 fl4 = &inet->cork.fl.u.ip4;
40
41 //如果使用了来源地址路由，选择一个合适的下一跳地址。
42 rt = ip_route_connect(fl4, nexthop, inet->inet_saddr,
43 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
44 IPPROTO_TCP,
45 orig_sport, orig_dport, sk);
46 if (IS_ERR(rt)) {
47 err = PTR_ERR(rt);
48 if (err == -ENETUNREACH)
49 IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTNOROUTES);
50 return err;
51 }
52 ...
53 后面较长，不再展示。
在该函数主要完成：
1. 路由查找，得到下一跳地址，并更新socket对象的下一跳地址；
2. 将socket对象的状态设置为TCP_SYN_SENT；
3. 如果没设置序号初值，则选定一个随机初值；
4. 调用函数tcp_connect完成报文构建和发送。
我接着看下tcp_connect：
1 /* Build a SYN and send it off. */
2 //由tcp_v4_connect()->tcp_connect()->tcp_transmit_skb()发送，并置为TCP_SYN_SENT.
3 int tcp_connect(struct sock *sk)
4 {
5 struct tcp_sock *tp = tcp_sk(sk);
6 struct sk_buff *buff;
7 int err;
8
9 //初始化传输控制块中与连接相关的成员
10 tcp_connect_init(sk);
11
12 if (unlikely(tp->repair)) {
13 tcp_finish_connect(sk, NULL);
14 return 0;
15 }
16 //分配skbuff --> 为SYN段分配报文并进行初始化
17 buff = sk_stream_alloc_skb(sk, 0, sk->sk_allocation, true);
18 if (unlikely(!buff))
19 return -ENOBUFS;
20
21 //构建syn报文
22
23 //在函数tcp_v4_connect中write_seq已经被初始化随机值
24 tcp_init_nondata_skb(buff, tp->write_seq++, TCPHDR_SYN);
25
26 tp->retrans_stamp = tcp_time_stamp;
27
28 //将报文添加到发送队列上
29 tcp_connect_queue_skb(sk, buff);
30
31 //显式拥塞通告 --->
32 //路由器在出现拥塞时通知TCP。当TCP段传递时，路由器使用IP首部中的2位来记录拥塞，当TCP段到达后，
33 //接收方知道报文段是否在某个位置经历过拥塞。然而，需要了解拥塞发生情况的是发送方，而非接收方。因
34 //此，接收方使用下一个ACK通知发送方有拥塞发生，然后，发送方做出响应，缩小自己的拥塞窗口。
35 tcp_ecn_send_syn(sk, buff);
36
37 /* Send off SYN; include data in Fast Open. */
38 err = tp->fastopen_req ? tcp_send_syn_data(sk, buff) :
39
40 //构造tcp头和ip头并发送
41 tcp_transmit_skb(sk, buff, 1, sk->sk_allocation);
42 if (err == -ECONNREFUSED)
43 return err;
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 TCP_INC_STATS(sock_net(sk), TCP_MIB_ACTIVEOPENS);
51
52 /* Timer for repeating the SYN until an answer. */
53
54 //启动重传定时器
55 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
56 inet_csk(sk)->icsk_rto, TCP_RTO_MAX);
57 return 0;
58 }
该函数完成：
1. 初始化套接字跟连接相关的字段；
2. 申请sk_buff空间；
3 . 将sk_buff初始化为syn报文，实质是操作tcp_skb_cb，在初始化TCP头的时候会用到；
4 . 调用tcp_connect_queue_skb()函数将报文sk_buff添加到发送队列sk->sk_write_queue；
5 . 调用tcp_transmit_skb()函数构造tcp头，然后交给网络层；
6. 初始化重传定时器。
接着我们进入tcp_connect_queue_skb：
1 /* This routine actually transmits TCP packets queued in by
2 * tcp_do_sendmsg(). This is used by both the initial
3 * transmission and possible later retransmissions.
4 * All SKB's seen here are completely headerless. It is our
5 * job to build the TCP header, and pass the packet down to
6 * IP so it can do the same plus pass the packet off to the
7 * device.
8 *
9 * We are working here with either a clone of the original
10 * SKB, or a fresh unique copy made by the retransmit engine.
11 */
12 static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it,
13 gfp_t gfp_mask)
14 {
15 const struct inet_connection_sock *icsk = inet_csk(sk);
16 struct inet_sock *inet;
17 struct tcp_sock *tp;
18 struct tcp_skb_cb *tcb;
19 struct tcp_out_options opts;
20 unsigned int tcp_options_size, tcp_header_size;
21 struct tcp_md5sig_key *md5;
22 struct tcphdr *th;
23 int err;
24
25 BUG_ON(!skb || !tcp_skb_pcount(skb));
26 tp = tcp_sk(sk);
27
28 //根据传递进来的clone_it参数来确定是否需要克隆待发送的报文
29 if (clone_it) {
30 skb_mstamp_get(&skb->skb_mstamp);
31 TCP_SKB_CB(skb)->tx.in_flight = TCP_SKB_CB(skb)->end_seq
32 - tp->snd_una;
33 tcp_rate_skb_sent(sk, skb);
34
35 //如果一个SKB会被不同的用户独立操作，而这些用户可能只是修改SKB描述符中的某些字段值，如h、nh，则内核没有必要为每个用户复制一份完整
36 //的SKB描述及其相应的数据缓存区，而会为了提高性能，只作克隆操作。克隆过程只复制SKB描述符，同时增加数据缓存区的引用计数，以免共享数
37 //据被提前释放。完成这些功能的是skb_clone()。一个使用包克隆的场景是，一个接收包程序要把该包传递给多个接收者，例如包处理函数或者一
38 //个或多个网络模块。原始的及克隆的SKB描述符的cloned值都会被设置为1，克隆SKB描述符的users值置为1，这样在第一次释放时就会释放掉。同时
39 //将数据缓存区引用计数dataref递增1，因为又多了一个克隆SKB描述符指向它
40
41 if (unlikely(skb_cloned(skb)))
42 //如果skb已经被clone，则只能复制该skb的数据到新分配的skb中
43 skb = pskb_copy(skb, gfp_mask);
44 else
45 skb = skb_clone(skb, gfp_mask);
46 if (unlikely(!skb))
47 return -ENOBUFS;
48 }
49 ...
50 后面较长，不再展示。
可以看到主要是移动sk_buff的data指针，然后填充TCP头，接着的事就是交给网络层，将报文发出。这样三次握手中的第一次握手在客户端的层面完成，报文到达服务端，由服务端处理完毕后，第一次握手完成，客户端socket状态变为TCP_SYN_SENT。下面我们看下服务端的处理。
数据到达网卡的时候，对于TCP协议，将大致要经过这个一个调用链：
网卡驱动 ---> netif_receive_skb() ---> ip_rcv() ---> ip_local_deliver_finish() ---> tcp_v4_rcv()
我们直接看tcp_v4_rcv():
1 /*
2 * From tcp_input.c
3 */
4
5 //网卡驱动-->netif_receive_skb()--->ip_rcv()--->ip_local_deliver_finish()---> tcp_v4_rcv()
6 int tcp_v4_rcv(struct sk_buff *skb)
7 {
8 struct net *net = dev_net(skb->dev);
9 const struct iphdr *iph;
10 const struct tcphdr *th;
11 bool refcounted;
12 struct sock *sk;
13 int ret;
14
15 //如果不是发往本地的数据包，则直接丢弃
16 if (skb->pkt_type != PACKET_HOST)
17 goto discard_it;
18
19 /* Count it even if it's bad */
20 __TCP_INC_STATS(net, TCP_MIB_INSEGS);
21
22
23 ////包长是否大于TCP头的长度
24 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
25 goto discard_it;
26
27 //tcp头 --> 不是很懂为何老是获取tcp头
28 th = (const struct tcphdr *)skb->data;
29 ...
30 后面较长，不再展示。
该函数主要工作就是根据tcp头部信息查到处理报文的socket对象，然后检查socket状态做不同处理，我们这里是监听状态TCP_LISTEN，直接调用函数tcp_v4_do_rcv():
1 /* The socket must have it's spinlock held when we get
2 * here, unless it is a TCP_LISTEN socket.
3 *
4 * We have a potential double-lock case here, so even when
5 * doing backlog processing we use the BH locking scheme.
6 * This is because we cannot sleep with the original spinlock
7 * held.
8 */
9
10 //网卡驱动-->netif_receive_skb()--->ip_rcv()--->ip_local_deliver_finish()---> tcp_v4_rcv()
11
12
13 //tcp_v4_do_rcv() -> tcp_rcv_state_process() -> tcp_v4_conn_request() -> tcp_v4_send_synack()
14 int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
15 {
16 struct sock *rsk;
17
18 //如果是连接已建立状态
19 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
20 struct dst_entry *dst = sk->sk_rx_dst;
21
22 sock_rps_save_rxhash(sk, skb);
23 sk_mark_napi_id(sk, skb);
24 if (dst) {
25 if (inet_sk(sk)->rx_dst_ifindex != skb->skb_iif ||
26 !dst->ops->check(dst, 0)) {
27 dst_release(dst);
28 sk->sk_rx_dst = NULL;
29 }
30 }
31 tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len);
32 return 0;
33 }
34 ...
35 后面较长，不再展示。
在这里并没有很多代码，做的东西也不是很多，对于监听状态的套接字，主要是一个SYN FLOOD防范相关的东西，不是我们研究的重点；接着就是调用tcp_rcv_state_process()：
1 /*
2 * This function implements the receiving procedure of RFC 793 for
3 * all states except ESTABLISHED and TIME_WAIT.
4 * It's called from both tcp_v4_rcv and tcp_v6_rcv and should be
5 * address independent.
6 */
7
8
9 //除了ESTABLISHED和TIME_WAIT状态外，其他状态下的TCP段处理都由本函数实现
10
11 // tcp_v4_do_rcv() -> tcp_rcv_state_process() -> tcp_v4_conn_request() -> tcp_v4_send_synack().
12 int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb)
13 {
14 struct tcp_sock *tp = tcp_sk(sk);
15 struct inet_connection_sock *icsk = inet_csk(sk);
16 const struct tcphdr *th = tcp_hdr(skb);
17 struct request_sock *req;
18 int queued = 0;
19 bool acceptable;
20
21 switch (sk->sk_state) {
22
23 //SYN_RECV状态的处理
24 case TCP_CLOSE:
25 goto discard;
26
27 //服务端第一次握手处理
28 case TCP_LISTEN:
29 if (th->ack)
30 return 1;
31
32 if (th->rst)
33 goto discard;
34
35 if (th->syn) {
36 if (th->fin)
37 goto discard;
38 // tcp_v4_do_rcv() -> tcp_rcv_state_process() -> tcp_v4_conn_request() -> tcp_v4_send_synack().
39 if (icsk->icsk_af_ops->conn_request(sk, skb) < 0)
40 return 1;
41
42 consume_skb(skb);
43 return 0;
44 }
45 goto discard;
46
47 ...
这是TCP建立连接的核心所在，几乎所有状态的套接字，在收到数据报时都在这里完成处理。对于服务端来说，收到第一次握手报文时的状态为TCP_LISTEN，处理代码为：
1 //服务端第一次握手处理
2 case TCP_LISTEN:
3 if (th->ack)
4 return 1;
5
6 if (th->rst)
7 goto discard;
8
9 if (th->syn) {
10 if (th->fin)
11 goto discard;
12 // tcp_v4_do_rcv() -> tcp_rcv_state_process() -> tcp_v4_conn_request() -> tcp_v4_send_synack().
13 if (icsk->icsk_af_ops->conn_request(sk, skb) < 0)
14 return 1;
15
16 consume_skb(skb);
17 return 0;
18 }
19 goto discard;
接下将由tcp_v4_conn_request函数处理，而tcp_v4_conn_request实际上调用tcp_conn_request：
1 // tcp_v4_do_rcv() -> tcp_rcv_state_process() -> tcp_v4_conn_request() -> tcp_v4_send_synack().
2 int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
3 {
4 /* Never answer to SYNs send to broadcast or multicast */
5 if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
6 goto drop;
7
8 //tcp_request_sock_ops 定义在 tcp_ipv4.c 1256行
9
10 //inet_init --> proto_register --> req_prot_init -->初始化cache名
11 return tcp_conn_request(&tcp_request_sock_ops,
12 &tcp_request_sock_ipv4_ops, sk, skb);
13
14 drop:
15 tcp_listendrop(sk);
16 return 0;
17 }
18 int tcp_conn_request(struct request_sock_ops *rsk_ops,
19 const struct tcp_request_sock_ops *af_ops,
20 struct sock *sk, struct sk_buff *skb)
21 ...
在该函数中做了不少的事情，但是我们这里重点了解两点：
1. 分配一个request_sock对象来代表这次连接请求（状态为TCP_NEW_SYN_RECV），如果没有设置防范syn flood相关的选项，则将该request_sock添加到established状态的tcp_sock散列表（如果设置了防范选项，则request_sock对象都没有，只有建立完成时才会分配）；
2. 调用tcp_v4_send_synack回复客户端ack，开启第二次握手。
我们看下该函数：
1 //向客户端发送SYN+ACK报文
2 static int tcp_v4_send_synack(const struct sock *sk, struct dst_entry *dst,
3 struct flowi *fl,
4 struct request_sock *req,
5 struct tcp_fastopen_cookie *foc,
6 enum tcp_synack_type synack_type)
7 {
8 const struct inet_request_sock *ireq = inet_rsk(req);
9 struct flowi4 fl4;
10 int err = -1;
11 struct sk_buff *skb;
12
13 /* First, grab a route. */
14
15 //查找到客户端的路由
16 if (!dst && (dst = inet_csk_route_req(sk, &fl4, req)) == NULL)
17 return -1;
18
19 //根据路由、传输控制块、连接请求块中的构建SYN+ACK段
20 skb = tcp_make_synack(sk, dst, req, foc, synack_type);
21
22 //生成SYN+ACK段成功
23 if (skb) {
24
25 //生成校验码
26 __tcp_v4_send_check(skb, ireq->ir_loc_addr, ireq->ir_rmt_addr);
27
28
29 //生成IP数据报并发送出去
30 err = ip_build_and_send_pkt(skb, sk, ireq->ir_loc_addr,
31 ireq->ir_rmt_addr,
32 ireq->opt);
33 err = net_xmit_eval(err);
34 }
35
36 return err;
37 }
代码较少，查找客户端路由，构造syn包，然后调用ip_build_and_send_pkt，依靠网络层将数据报发出去。至此，第一次握手完成，第二次握手服务端层面完成。
数据报到达客户端网卡，同样经过：网卡驱动-->netif_receive_skb()--->ip_rcv()--->ip_local_deliver_finish()---> tcp_v4_rcv() --> tcp_v4_do_rcv() 。
客户端socket的状态为TCP_SYN_SENT，所以直接进入tcp_rcv_state_process，处理该状态的代码为：
1 //客户端第二次握手处理 2 case TCP_SYN_SENT: 3 tp->rx_opt.saw_tstamp = 0; 4 5 //处理SYN_SENT状态下接收到的TCP段 6 queued = tcp_rcv_synsent_state_process(sk, skb, th); 7 if (queued >= 0) 8 return queued; 9 10 /* Do step6 onward by hand. */ 11 12 //处理完第二次握手后，还需要处理带外数据 13 tcp_urg(sk, skb, th); 14 __kfree_skb(skb); 15 16 //检测是否有数据需要发送 17 tcp_data_snd_check(sk); 18 return 0; 19 }
接着看tcp_rcv_synsent_state_process：
1 //在SYN_SENT状态下处理接收到的段，但是不处理带外数据
2 static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb,
3 const struct tcphdr *th)
4 {
5 struct inet_connection_sock *icsk = inet_csk(sk);
6 struct tcp_sock *tp = tcp_sk(sk);
7 struct tcp_fastopen_cookie foc = { .len = -1 };
8 int saved_clamp = tp->rx_opt.mss_clamp;
9
10 //解析TCP选项并保存到传输控制块中
11 tcp_parse_options(skb, &tp->rx_opt, 0, &foc);
12 if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr)
13 tp->rx_opt.rcv_tsecr -= tp->tsoffset;
14
15 ...
处理三种可能的包：
1. 带ack标志的，这是我们预期的；
2. 带rst标志的，直接丢掉传输控制块；
3. 带syn标志，但是没有ack标志，两者同时发起连接。
我们重点研究第一种情况。首先调用tcp_finish_connect设置sock状态为TCP_ESTABLISHED：
1 void tcp_finish_connect(struct sock *sk, struct sk_buff *skb)
2 {
3 struct tcp_sock *tp = tcp_sk(sk);
4 struct inet_connection_sock *icsk = inet_csk(sk);
5
6 //设置sock状态为TCP_ESTABLISHED
7 tcp_set_state(sk, TCP_ESTABLISHED);
8
9 if (skb) {
10 icsk->icsk_af_ops->sk_rx_dst_set(sk, skb);
11 security_inet_conn_established(sk, skb);
12 }
13 ...
接着延时发送或立即发送确认ack，我们先不去了解延时确认的东西，我们直接看直接发送确认ack，调用tcp_send_ack：
1 //主动连接时，向服务器端发送ACK完成连接，并更新窗口
2 void tcp_send_ack(struct sock *sk)
3 {
4 struct sk_buff *buff;
5
6 /* If we have been reset, we may not send again. */
7 if (sk->sk_state == TCP_CLOSE)
8 return;
9
10 tcp_ca_event(sk, CA_EVENT_NON_DELAYED_ACK);
11 ...
比较简单，无非是构造报文，然后交给网络层发送。至此第二次握手完成，客户端sock状态变为TCP_ESTABLISHED，第三次握手开始。我们之前说到服务端的sock的状态为TCP_NEW_SYN_RECV，报文到达网卡：
网卡驱动-->netif_receive_skb()--->ip_rcv()--->ip_local_deliver_finish()---> tcp_v4_rcv()，报文将被以下代码处理:
1 //网卡驱动-->netif_receive_skb()--->ip_rcv()--->ip_local_deliver_finish()---> tcp_v4_rcv()
2 int tcp_v4_rcv(struct sk_buff *skb)
3 {
4 .............
5
6
7 //收到握手最后一个ack后，会找到TCP_NEW_SYN_RECV状态的req，然后创建一个新的sock进入TCP_SYN_RECV状态，最终进入TCP_ESTABLISHED状态. 并放入accept队列通知select/epoll
8 if (sk->sk_state == TCP_NEW_SYN_RECV) {
9 struct request_sock *req = inet_reqsk(sk);
10 struct sock *nsk;
11
12 sk = req->rsk_listener;
13 if (unlikely(tcp_v4_inbound_md5_hash(sk, skb))) {
14 sk_drops_add(sk, skb);
15 reqsk_put(req);
16 goto discard_it;
17 }
18 ...
看下如何创建新sock，进入tcp_check_req():
1 struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb,
2 struct request_sock *req,
3 bool fastopen)
4 {
5 struct tcp_options_received tmp_opt;
6 struct sock *child;
7 const struct tcphdr *th = tcp_hdr(skb);
8 __be32 flg = tcp_flag_word(th) & (TCP_FLAG_RST|TCP_FLAG_SYN|TCP_FLAG_ACK);
9 bool paws_reject = false;
10 bool own_req;
11 ...
又回到了函数tcp_rcv_state_process，TCP_SYN_RECV状态的套接字将由一下代码处理：
1 //服务端第三次握手处理
2 case TCP_SYN_RECV:
3 if (!acceptable)
4 return 1;
5
6 if (!tp->srtt_us)
7 tcp_synack_rtt_meas(sk, req);
8
9 /* Once we leave TCP_SYN_RECV, we no longer need req
10 * so release it.
11 */
12 if (req) {
13 inet_csk(sk)->icsk_retransmits = 0;
14 reqsk_fastopen_remove(sk, req, false);
15 } else {
16 /* Make sure socket is routed, for correct metrics. */
17
18 //建立路由，初始化拥塞控制模块
19 icsk->icsk_af_ops->rebuild_header(sk);
20 tcp_init_congestion_control(sk);
21
22 tcp_mtup_init(sk);
23 tp->copied_seq = tp->rcv_nxt;
24 tcp_init_buffer_space(sk);
25 }
26 smp_mb();
27 //正常的第三次握手，设置连接状态为TCP_ESTABLISHED
28 tcp_set_state(sk, TCP_ESTABLISHED);
29 sk->sk_state_change(sk);
30
31 /* Note, that this wakeup is only for marginal crossed SYN case.
32 * Passively open sockets are not waked up, because
33 * sk->sk_sleep == NULL and sk->sk_socket == NULL.
34 */
35
36 //状态已经正常，唤醒那些等待的线程
37 if (sk->sk_socket)
38 sk_wake_async(sk, SOCK_WAKE_IO, POLL_OUT);
39
40 tp->snd_una = TCP_SKB_CB(skb)->ack_seq;
41 tp->snd_wnd = ntohs(th->window) << tp->rx_opt.snd_wscale;
42 tcp_init_wl(tp, TCP_SKB_CB(skb)->seq);
43
44 if (tp->rx_opt.tstamp_ok)
45 tp->advmss -= TCPOLEN_TSTAMP_ALIGNED;
46
47 if (req) {
48 /* Re-arm the timer because data may have been sent out.
49 * This is similar to the regular data transmission case
50 * when new data has just been ack'ed.
51 *
52 * (TFO) - we could try to be more aggressive and
53 * retransmitting any data sooner based on when they
54 * are sent out.
55 */
56 tcp_rearm_rto(sk);
57 } else
58 tcp_init_metrics(sk);
59
60 if (!inet_csk(sk)->icsk_ca_ops->cong_control)
61 tcp_update_pacing_rate(sk);
62
63 /* Prevent spurious tcp_cwnd_restart() on first data packet */
64
65 //更新最近一次发送数据包的时间
66 tp->lsndtime = tcp_time_stamp;
67
68 tcp_initialize_rcv_mss(sk);
69
70 //计算有关TCP首部预测的标志
71 tcp_fast_path_on(tp);
72 break;
可以看到到代码对sock的窗口，mss等进行设置，以及最后将sock的状态设置为TCP_ESTABLISHED，至此三次握手完成。等待用户调用accept调用，取出套接字使用。
分析过程中的断点设置情况如下图：
现在给出大体的TCP三次握手协议栈从上至下提供的接口，具体的详细过程见上面的分析：
TCP三次握手协议栈从上至下提供的接口
如下图所示：
总结
本文内容主要分为三个部分，首先讲述了TCP协议的相关知识，接着谈到了与TCP通信联系密切的linux socket接口函数及应用层处理TCP连接的详细流程，最后通过gdb调试加阅读源码的方式，一步步揭开socket接口函数背后的TCP三次握手的神秘面纱，详细地从linux 系统函数调用的角度理解了TCP连接建立三次握手的过程，相信我们对TCP协议的理解又有了一个新的高度！