三次握手四次挥手

TCP协议是一种面向连接的、可靠的、基于字节流的运输层通信协议。它通过三次握手来建立连接，通过四次挥手来断开连接。

三次握手

所谓三次握手，是指建立一个TCP连接时，需要客户端和服务器总共发送3个报文。三次握手的目的是连接服务器指定端口，建立TCP连接，并同步连接双方的序列号和确认号，交换TCP窗口大小信息。

三次握手过程的示意图如下：

    客户端                        服务器
      |                           |
      |     SYN seq=x             | 第一次握手
      |-------------------------->|
      |                           |
      |     SYN seq=y, ACK ack=x+1| 第二次握手
      |<--------------------------|
      |                           |
      |     ACK ack=y+1           | 第三次握手
      |-------------------------->|
      |                           |
1
2
3
4
5
6
7
8
9
10
11

第一次握手：客户端向服务器发送一个SYN报文段，表示请求建立连接，并随机选择一个初始序号x。发送完毕后，客户端进入SYN_SENT状态，等待服务器端确认。
第二次握手：服务器收到SYN报文段后，如果同意建立连接，就向客户端发送一个SYN+ACK报文段，表示确认客户端的请求，并随机选择一个初始序号y。同时，服务器将客户端的序号x加一作为自己的确认号ack。服务器进入SYN_RECV状态，等待客户端的确认。
第三次握手：客户端收到SYN+ACK报文段后，向服务器发送一个ACK报文段，表示确认服务器的回应，并将服务器的序号y加一作为自己的确认号ack。客户端进入ESTABLISHED状态，表示连接已经建立。服务器收到ACK报文段后，也进入ESTABLISHED状态，表示连接已经建立。

三次握手的伪代码

// 客户端
send SYN(x) // 发送SYN报文段，x为初始序号
state = SYN_SENT // 进入SYN_SENT状态
receive SYN(y)+ACK(x+1) // 接收SYN+ACK报文段，y为初始序号
send ACK(y+1) // 发送ACK报文段
state = ESTABLISHED // 进入ESTABLISHED状态

// 服务器
receive SYN(x) // 接收SYN报文段
send SYN(y)+ACK(x+1) // 发送SYN+ACK报文段
state = SYN_RECV // 进入SYN_RECV状态
receive ACK(y+1) // 接收ACK报文段
state = ESTABLISHED // 进入ESTABLISHED状态
1
2
3
4
5
6
7
8
9
10
11
12
13

c++代码

// 客户端
#include 
#include 
#include 
#include 
#include 
using namespace std;

int main() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0); // 创建套接字
    if (sockfd == -1) {
        cout << "socket error" << endl;
        return -1;
    }
    struct sockaddr_in servaddr; // 服务器地址结构体
    servaddr.sin_family = AF_INET; // 地址族
    servaddr.sin_port = htons(8888); // 端口号
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); // IP地址

    int res = connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr)); // 发起连接请求
    if (res == -1) {
        cout << "connect error" << endl;
        return -1;
    }
    cout << "connect success" << endl;

    close(sockfd); // 关闭套接字
    return 0;
}

// 服务器
#include 
#include 
#include 
#include 
#include 
using namespace std;

int main() {
    int listenfd = socket(AF_INET, SOCK_STREAM, 0); // 创建监听套接字
    if (listenfd == -1) {
        cout << "socket error" << endl;
        return -1;
    }
    struct sockaddr_in servaddr; // 服务器地址结构体
    servaddr.sin_family = AF_INET; // 地址族
    servaddr.sin_port = htons(8888); // 端口号
    servaddr.sin_addr.s_addr = INADDR_ANY; // IP地址

    int res = bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)); // 绑定地址和端口
    if (res == -1) {
        cout << "bind error" << endl;
        return -1;
    }

    res = listen(listenfd, 5); // 开始监听
    if (res == -1) {
        cout << "listen error" << endl;
        return -1;
    }
    cout << "listening..." << endl;

    struct sockaddr_in cliaddr; // 客户端地址结构体
    socklen_t len = sizeof(cliaddr); // 地址长度
    int connfd = accept(listenfd, (struct sockaddr*)&cliaddr, &len); // 接受连接请求
    if (connfd == -1) {
        cout << "accept error" << endl;
        return -1;
    }
    cout << "accept success" << endl;

    close(connfd); // 关闭连接套接字
    close(listenfd); // 关闭监听套接字
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

四次挥手

所谓四次挥手，是指断开一个TCP连接时，需要客户端和服务器总共发送4个报文。四次挥手的目的是终止数据传输，并释放双方的资源。由于TCP是全双工模式，所以每个方向都需要单独进行关闭。

四次挥手过程的示意图如下：

    客户端                        服务器
      |                           |
      |     FIN seq=u             | 第一次挥手
      |-------------------------->|
      |                           |
      |     ACK ack=u+1           | 第二次挥手
      |<--------------------------|
      |                           |
      |     FIN seq=v             | 第三次挥手
      |<--------------------------|
      |                           |
      |     ACK ack=v+1           | 第四次挥手
      |-------------------------->|
      |                           |
1
2
3
4
5
6
7
8
9
10
11
12
13
14

第一次挥手：主动关闭方向被动关闭方发送一个FIN报文段，表示请求关闭连接，并停止发送数据。主动关闭方进入FIN_WAIT_1状态，等待被动关闭方的回应。
第二次挥手：被动关闭方收到FIN报文段后，向主动关闭方发送一个ACK报文段，表示确认收到请求，并继续发送数据。被动关闭方进入CLOSE_WAIT状态，等待数据发送完毕。主动关闭方收到ACK报文段后，进入FIN_WAIT_2状态，等待被动关闭方的关闭请求。
第三次挥手：被动关闭方发送完所有数据后，向主动关闭方发送一个FIN报文段，表示请求关闭连接，并停止发送数据。被动关闭方进入LAST_ACK状态，等待主动关闭方的确认。
第四次挥手：主动关闭方收到FIN报文段后，向被动关闭方发送一个ACK报文段，表示确认收到请求，并进入TIME_WAIT状态，等待一段时间后释放资源。被动关闭方收到ACK报文段后，进入CLOSED状态，释放资源。

四次挥手伪代码

// 主动关闭方
send FIN // 发送FIN报文段
state = FIN_WAIT_1 // 进入FIN_WAIT_1状态
receive ACK // 接收ACK报文段
state = FIN_WAIT_2 // 进入FIN_WAIT_2状态
receive FIN // 接收FIN报文段
send ACK // 发送ACK报文段
state = TIME_WAIT // 进入TIME_WAIT状态
wait 2MSL // 等待2MSL时间
state = CLOSED // 进入CLOSED状态

// 被动关闭方
receive FIN // 接收FIN报文段
send ACK // 发送ACK报文段
state = CLOSE_WAIT // 进入CLOSE_WAIT状态
send all data // 发送所有数据
send FIN // 发送FIN报文段
state = LAST_ACK // 进入LAST_ACK状态
receive ACK // 接收ACK报文段
state = CLOSED // 进入CLOSED状态
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

c++代码

// 主动关闭方（客户端）
#include 
#include 
#include 
#include 
#include 
using namespace std;

int main() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0); // 创建套接字
    if (sockfd == -1) {
        cout << "socket error" << endl;
        return -1;
    }
    struct sockaddr_in servaddr; // 服务器地址结构体
    servaddr.sin_family = AF_INET; // 地址族
    servaddr.sin_port = htons(8888); // 端口号
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); // IP地址

    int res = connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr)); // 发起连接请求
    if (res == -1) {
        cout << "connect error" << endl;
        return -1;
    }
    cout << "connect success" << endl;

    char buf[1024]; // 缓冲区

    while (true) {
        cin.getline(buf, sizeof(buf)); // 从标准输入读取一行数据
        if (strcmp(buf, "exit") == 0) { // 如果输入exit，则退出循环
            break;
        }
        res = write(sockfd, buf, strlen(buf)); // 向服务器发送数据
        if (res == -1) {
            cout << "write error" << endl;
            return -1;
        }
        res = read(sockfd, buf, sizeof(buf)-1); // 从服务器接收数据
        if (res == -1) {
            cout << "read error" << endl;
            return -1;
        }
        buf[res] = 0; // 添加字符串结束符
        cout << buf << endl; // 输出服务器回复的数据
    }

    res = shutdown(sockfd, SHUT_WR); // 发送FIN报文段，请求关闭连接
    if (res == -1) {
        cout << "shutdown error" << endl;
        return -1;
    }
    cout << "shutdown success" << endl;

    res = read(sockfd, buf, sizeof(buf)-1); // 接收服务器的最后一个数据包
    if (res == -1) {
        cout << "read error" << endl;
        return -1;
    }
    buf[res] = 0; // 添加字符串结束符
    cout << buf << endl; // 输出服务器的最后一个数据包

    close(sockfd); // 关闭套接字
    return 0;
}

// 被动关闭方（服务器）
#include 
#include 
#include 
#include 
#include 
using namespace std;

int main() {
    int listenfd = socket(AF_INET, SOCK_STREAM, 0); // 创建监听套接字
    if (listenfd == -1) {
        cout << "socket error" << endl;
        return -1;
    }
    struct sockaddr_in servaddr; // 服务器地址结构体
    servaddr.sin_family = AF_INET; // 地址族
    servaddr.sin_port = htons(8888); // 端口号
    servaddr.sin_addr.s_addr = INADDR_ANY; // IP地址

    int res = bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)); // 绑定地址和端口
    if (res == -1) {
        cout << "bind error" << endl;
        return -1;
    }

    res = listen(listenfd, 5); // 开始监听
    if (res == -1) {
        cout << "listen error" << endl;
        return -1;
    }
    cout << "listening..." << endl;

    struct sockaddr_in cliaddr; // 客户端地址结构体
    socklen_t len = sizeof(cliaddr); // 地址长度
    int connfd = accept(listenfd, (struct sockaddr*)&cliaddr, &len); // 接受连接请求
    if (connfd == -1) {
        cout << "accept error" << endl;
        return -1;
    }
    cout << "accept success" << endl;

    char buf[1024]; // 缓冲区

    while (true) {
        res = read(connfd, buf, sizeof(buf)-1); // 从客户端接收数据
        if (res == -1) {
            cout << "read error" << endl;
            return -1;
        }
        if (res == 0) { // 如果收到FIN报文段，表示客户端请求关闭连接
            break;
        }
        buf[res] = 0; // 添加字符串结束符
        cout << buf << endl; // 输出客户端发送的数据
        res = write(connfd, buf, strlen(buf)); // 向客户端发送数据
        if (res == -1) {
            cout << "write error" << endl;
            return -1;
        }
    }

    strcpy(buf, "bye"); // 准备最后一个数据包
    res = write(connfd, buf, strlen(buf)); // 向客户端发送最后一个数据包
    if (res == -1) {
        cout << "write error" << endl;
        return -1;
    }

    res = shutdown(connfd, SHUT_WR); // 发送FIN报文段，请求关闭连接
    if (res == -1) {
        cout << "shutdown error" << endl;
        return -1;
    }
    cout << "shutdown success" << endl;

    close(connfd); // 关闭连接套接字
    close(listenfd); // 关闭监听套接字
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

常见问题

为什么连接的时候是三次握手，关闭的时候却是四次挥手？

答：因为当服务器端收到客户端的SYN连接请求报文后，可以直接发送SYN+ACK报文。其中ACK报文是用来应答的，SYN报文是用来同步的。但是关闭连接时，当服务器端收到FIN报文时，很可能并不会立即关闭SOCKET，所以只能先回复一个ACK报文，告诉客户端，“你发的FIN报文我收到了”。只有等到服务器端所有的报文都发送完了，服务器端才能发送FIN报文，因此不能一起发送。故需要四步握手。

为什么TIME_WAIT状态需要经过2MSL（最大报文段生存时间）才能返回到CLOSE状态？

答：虽然按道理，四个报文都发送完毕，我们可以直接进入CLOSE状态了，但是我们必须假象网络是不可靠的，有可能最后一个ACK丢失。所以TIME_WAIT状态就是用来重发可能丢失的ACK报文。在客户端发送出最后的ACK回复，但该ACK可能丢失。服务器端如果没有收到ACK，将不断重复发送FIN片段。所以客户端不能立即关闭，它必须确认服务器端接收到了该ACK。客户端会在发送出ACK之后进入到TIME_WAIT状态。客户端会设置一个计时器，等待2MSL的时间。如果在该时间内再次收到FIN，那么客户端会重发ACK并再次等待2MSL。所谓的2MSL是两倍的MSL（Maximum Segment Lifetime）。MSL指一个片段在网络中最大的存活时间，2MSL就是一个发送和一个回复所需的最大时间。如果直到2MSL，客户端都没有再次收到FIN，那么客户端推断ACK已经被成功接收，则结束TCP连接。

为什么不能用两次握手进行连接？

答：3次握手完成两个重要的功能，既要双方做好发送数据的准备工作（双方都知道彼此已准备好），也要允许双方就初始序列号进行协商，这个序列号在握手过程中被发送和确认。现在把三次握手改成仅需要两次握手，死锁是可能发生的。作为例子，考虑计算机S和C之间的通信，假定C给S发送一个连接请求分组，S收到了这个分组，并发送了确认应答分组。按照两次握手的协定，S认为连接已经成功地建立了，可以开始发送数据分组。可是，C在S的应答分组在传输中被丢失的情况下，将不知道S是否已准备好，不知道S建立什么样的序列号，C甚至怀疑S是否收到自己的连接请求分组。在这种情况下，C认为连接还未建立成功，将忽略S发来的任何数据分组，只等待连接确认应答分组。而S在发出的分组超时后，重复发送同样的分组。这样就形成了死锁。

相关阅读:
k8s 集群安装(vagrant + virtualbox + CentOS8)
操作系统历史---03
【开源】基于Vue和SpringBoot的教学过程管理系统
 【hive & Hadoop】踩坑记录
 Vue脚手架项目结构分析
 CSI（Container Storage Interface）
Vue+java 实现时间段的搜索
 docker学习第二天
 Python 导入Excel三维坐标数据生成三维曲面地形图(体) 5-2、线条平滑曲面且可通过面观察柱体变化(二)
嵌入式养成计划-53----ARM--串口通信
原文地址：https://blog.csdn.net/weixin_47895938/article/details/132733954