TCP连接与断开详解（socket通信）

野性酷女 2022-05-17 12:59 384阅读 0赞

http://blog.csdn.net/Ctrl\_qun/article/details/52518479

一、TCP数据报结构以及三次握手

TCP（Transmission Control Protocol，传输控制协议）是一种面向连接的、可靠的、基于字节流的通信协议，数据在传输前要建立连接，传输完毕后还要断开连接。

客户端在收发数据前要使用 connect() 函数和服务器建立连接。建立连接的目的是保证IP地址、端口、物理链路等正确无误，为数据的传输开辟通道。  
  
TCP建立连接时要传输三个数据包，俗称三次握手（Three-way Handshaking）。可以形象的比喻为下面的对话：

*  \[Shake 1\] 套接字A：“你好，套接字B，我这里有数据要传送给你，建立连接吧。”
 *  \[Shake 2\] 套接字B：“好的，我这边已准备就绪。”
 *  \[Shake 3\] 套接字A：“谢谢你受理我的请求。”

## TCP数据报结构 ##

我们先来看一下TCP数据报的结构：  
![1-151020115S23R.jpg][]  
  
带阴影的几个字段需要重点说明一下：  
1) 序号：Seq（Sequence Number）序号占32位，用来标识从计算机A发送到计算机B的数据包的序号，计算机发送数据时对此进行标记。  
  
2) 确认号：Ack（Acknowledge Number）确认号占32位，客户端和服务器端都可以发送，Ack = Seq + 1。

3) 标志位：每个标志位占用1Bit，共有6个，分别为 URG、ACK、PSH、RST、SYN、FIN，具体含义如下：

URG：紧急指针（urgent pointer）有效。

ACK：确认序号有效。

PSH：接收方应该尽快将这个报文交给应用层。

RST：重置连接。

SYN：建立一个新连接。

FIN：断开一个连接。

> 对英文字母缩写的总结：Seq 是 Sequence 的缩写，表示序列；Ack(ACK) 是 Acknowledge 的缩写，表示确认；SYN 是 Synchronous 的缩写，愿意是“同步的”，这里表示建立同步连接；FIN 是 Finish 的缩写，表示完成。

## 连接的建立（三次握手） ##

使用 connect() 建立连接时，客户端和服务器端会相互发送三个数据包，请看下图：  
![1-151020132J32G.jpg][]  
  
客户端调用 socket() 函数创建套接字后，因为没有建立连接，所以套接字处于`CLOSED`状态；服务器端调用 listen() 函数后，套接字进入`LISTEN`状态，开始监听客户端请求。  
  
这个时候，客户端开始发起请求：  
1) 当客户端调用 connect() 函数后，TCP协议会组建一个数据包，并设置 SYN 标志位，表示该数据包是用来建立同步连接的。同时生成一个随机数字 1000，填充“序号（Seq）”字段，表示该数据包的序号。完成这些工作，开始向服务器端发送数据包，客户端就进入了`SYN-SEND`状态。  
  
2) 服务器端收到数据包，检测到已经设置了 SYN 标志位，就知道这是客户端发来的建立连接的“请求包”。服务器端也会组建一个数据包，并设置 SYN 和 ACK 标志位，SYN 表示该数据包用来建立连接，ACK 用来确认收到了刚才客户端发送的数据包。  
  
服务器生成一个随机数 2000，填充“序号（Seq）”字段。2000 和客户端数据包没有关系。  
  
服务器将客户端数据包序号（1000）加1，得到1001，并用这个数字填充“确认号（Ack）”字段。  
  
服务器将数据包发出，进入`SYN-RECV`状态。  
  
3) 客户端收到数据包，检测到已经设置了 SYN 和 ACK 标志位，就知道这是服务器发来的“确认包”。客户端会检测“确认号（Ack）”字段，看它的值是否为 1000+1，如果是就说明连接建立成功。  
  
接下来，客户端会继续组建数据包，并设置 ACK 标志位，表示客户端正确接收了服务器发来的“确认包”。同时，将刚才服务器发来的数据包序号（2000）加1，得到 2001，并用这个数字来填充“确认号（Ack）”字段。  
  
客户端将数据包发出，进入`ESTABLISED`状态，表示连接已经成功建立。  
  
4) 服务器端收到数据包，检测到已经设置了 ACK 标志位，就知道这是客户端发来的“确认包”。服务器会检测“确认号（Ack）”字段，看它的值是否为 2000+1，如果是就说明连接建立成功，服务器进入`ESTABLISED`状态。  
  
至此，客户端和服务器都进入了`ESTABLISED`状态，连接建立成功，接下来就可以收发数据了。

## 最后的说明 ##

三次握手的关键是要确认对方收到了自己的数据包，这个目标就是通过“确认号（Ack）”字段实现的。计算机会记录下自己发送的数据包序号 Seq，待收到对方的数据包后，检测“确认号（Ack）”字段，看`Ack = Seq + 1`是否成立，如果成立说明对方正确收到了自己的数据包。

二、TCP数据的传输过程

建立连接后，两台主机就可以相互传输数据了。如下图所示：

![1-15110510394G48.jpg][]  
图1：TCP 套接字的数据交换过程

上图给出了主机A分2次（分2个数据包）向主机B传递200字节的过程。首先，主机A通过1个数据包发送100个字节的数据，数据包的 Seq 号设置为 1200。主机B为了确认这一点，向主机A发送 ACK 包，并将 Ack 号设置为 1301。

> 为了保证数据准确到达，目标机器在收到数据包（包括SYN包、FIN包、普通数据包等）包后必须立即回传ACK包，这样发送方才能确认数据传输成功。

此时 Ack 号为 1301 而不是 1201，原因在于 Ack 号的增量为传输的数据字节数。假设每次 Ack 号不加传输的字节数，这样虽然可以确认数据包的传输，但无法明确100字节全部正确传递还是丢失了一部分，比如只传递了80字节。因此按如下的公式确认 Ack 号：

Ack号 = Seq号 + 传递的字节数 + 1

与三次握手协议相同，最后加 1 是为了告诉对方要传递的 Seq 号。  
  
下面分析传输过程中数据包丢失的情况，如下图所示：

![1-151106134A4196.jpg][]  
图2：TCP套接字数据传输过程中发生错误

上图表示通过 Seq 1301 数据包向主机B传递100字节的数据，但中间发生了错误，主机B未收到。经过一段时间后，主机A仍未收到对于 Seq 1301 的ACK确认，因此尝试重传数据。  
  
为了完成数据包的重传，TCP套接字每次发送数据包时都会启动定时器，如果在一定时间内没有收到目标机器传回的 ACK 包，那么定时器超时，数据包会重传。

> 上图演示的是数据包丢失的情况，也会有 ACK 包丢失的情况，一样会重传。

重传超时时间（RTO, Retransmission Time Out）

这个值太大了会导致不必要的等待，太小会导致不必要的重传，理论上最好是网络 RTT 时间，但又受制于网络距离与瞬态时延变化，所以实际上使用自适应的动态算法（例如 Jacobson 算法和 Karn 算法等）来确定超时时间。

> 往返时间（RTT，Round-Trip Time）表示从发送端发送数据开始，到发送端收到来自接收端的 ACK 确认包（接收端收到数据后便立即确认），总共经历的时延。

重传次数

TCP数据包重传次数根据系统设置的不同而有所区别。有些系统，一个数据包只会被重传3次，如果重传3次后还未收到该数据包的 ACK 确认，就不再尝试重传。但有些要求很高的业务系统，会不断地重传丢失的数据包，以尽最大可能保证业务数据的正常交互。

三、TCP四次握手断开连接

建立连接非常重要，它是数据正确传输的前提；断开连接同样重要，它让计算机释放不再使用的资源。如果连接不能正常断开，不仅会造成数据传输错误，还会导致套接字不能关闭，持续占用资源，如果并发量高，服务器压力堪忧。  
  
建立连接需要三次握手，断开连接需要四次握手，可以形象的比喻为下面的对话：

*  \[Shake 1\] 套接字A：“任务处理完毕，我希望断开连接。”
 *  \[Shake 2\] 套接字B：“哦，是吗？请稍等，我准备一下。”
 *  等待片刻后……
 *  \[Shake 3\] 套接字B：“我准备好了，可以断开连接了。”
 *  \[Shake 4\] 套接字A：“好的，谢谢合作。”

下图演示了客户端主动断开连接的场景：  
![1-15102015224Wc.jpg][]  
  
建立连接后，客户端和服务器都处于`ESTABLISED`状态。这时，客户端发起断开连接的请求：  
1) 客户端调用 close() 函数后，向服务器发送 FIN 数据包，进入`FIN_WAIT_1`状态。FIN 是 Finish 的缩写，表示完成任务需要断开连接。  
  
2) 服务器收到数据包后，检测到设置了 FIN 标志位，知道要断开连接，于是向客户端发送“确认包”，进入`CLOSE_WAIT`状态。  
  
注意：服务器收到请求后并不是立即断开连接，而是先向客户端发送“确认包”，告诉它我知道了，我需要准备一下才能断开连接。  
  
3) 客户端收到“确认包”后进入`FIN_WAIT_2`状态，等待服务器准备完毕后再次发送数据包。  
  
4) 等待片刻后，服务器准备完毕，可以断开连接，于是再主动向客户端发送 FIN 包，告诉它我准备好了，断开连接吧。然后进入`LAST_ACK`状态。  
  
5) 客户端收到服务器的 FIN 包后，再向服务器发送 ACK 包，告诉它你断开连接吧。然后进入`TIME_WAIT`状态。  
  
6) 服务器收到客户端的 ACK 包后，就断开连接，关闭套接字，进入`CLOSED`状态。

## 关于 TIME\_WAIT 状态的说明 ##

客户端最后一次发送 ACK包后进入 TIME\_WAIT 状态，而不是直接进入 CLOSED 状态关闭连接，这是为什么呢？  
  
TCP 是面向连接的传输方式，必须保证数据能够正确到达目标机器，不能丢失或出错，而网络是不稳定的，随时可能会毁坏数据，所以机器A每次向机器B发送数据包后，都要求机器B”确认“，回传ACK包，告诉机器A我收到了，这样机器A才能知道数据传送成功了。如果机器B没有回传ACK包，机器A会重新发送，直到机器B回传ACK包。  
  
客户端最后一次向服务器回传ACK包时，有可能会因为网络问题导致服务器收不到，服务器会再次发送 FIN 包，如果这时客户端完全关闭了连接，那么服务器无论如何也收不到ACK包了，所以客户端需要等待片刻、确认对方收到ACK包后才能进入CLOSED状态。那么，要等待多久呢？  
  
**数据包在网络中是有生存时间的，超过这个时间还未到达目标主机就会被丢弃，并通知源主机。这称为报文最大生存时间（MSL，Maximum Segment Lifetime）。TIME\_WAIT 要等待 2MSL 才会进入 CLOSED 状态。ACK 包到达服务器需要 MSL 时间，服务器重传 FIN 包也需要 MSL 时间，2MSL 是数据包往返的最大时间，如果 2MSL 后还未收到服务器重传的 FIN 包，就说明服务器已经收到了 ACK 包。**

四、优雅的断开连接--shutdown()

调用 close()/closesocket() 函数意味着完全断开连接，即不能发送数据也不能接收数据，这种“生硬”的方式有时候会显得不太“优雅”。

![1-15102016331RI.jpg][]  
图1：close()/closesocket() 断开连接

上图演示了两台正在进行双向通信的主机。主机A发送完数据后，单方面调用 close()/closesocket() 断开连接，之后主机A、B都不能再接受对方传输的数据。实际上，是完全无法调用与数据收发有关的函数。  
一般情况下这不会有问题，但有些特殊时刻，需要只断开一条数据传输通道，而保留另一条。  
使用 shutdown() 函数可以达到这个目的，它的原型为：**\[cpp\]** [view plain][] [copy][view plain]

1.  int shutdown(int sock, int howto);  //Linux  
2.  int shutdown(SOCKET s, int howto);  //Windows

sock 为需要断开的套接字，howto 为断开方式。  
  
howto 在 Linux 下有以下取值：

*  SHUT\_RD：断开输入流。套接字无法接收数据（即使输入缓冲区收到数据也被抹去），无法调用输入相关函数。
 *  SHUT\_WR：断开输出流。套接字无法发送数据，但如果输出缓冲区中还有未传输的数据，则将传递到目标主机。
 *  SHUT\_RDWR：同时断开 I/O 流。相当于分两次调用 shutdown()，其中一次以 SHUT\_RD 为参数，另一次以 SHUT\_WR 为参数。

howto 在 Windows 下有以下取值：

*  SD\_RECEIVE：关闭接收操作，也就是断开输入流。
 *  SD\_SEND：关闭发送操作，也就是断开输出流。
 *  SD\_BOTH：同时关闭接收和发送操作。

至于什么时候需要调用 shutdown() 函数，下节我们会以文件传输为例进行讲解。

close()/closesocket()和shutdown()的区别

确切地说，close() / closesocket() 用来关闭套接字，将套接字描述符（或句柄）从内存清除，之后再也不能使用该套接字，与C语言中的 fclose() 类似。应用程序关闭套接字后，与该套接字相关的连接和缓存也失去了意义，TCP协议会自动触发关闭连接的操作。  
shutdown() 用来关闭连接，而不是套接字，不管调用多少次 shutdown()，套接字依然存在，直到调用 close() / closesocket() 将套接字从内存清除。  
调用 close()/closesocket() 关闭套接字时，或调用 shutdown() 关闭输出流时，都会向对方发送 FIN 包。FIN 包表示数据传输完毕，计算机收到 FIN 包就知道不会再有数据传送过来了。  
默认情况下，close()/closesocket() 会立即向网络中发送FIN包，不管输出缓冲区中是否还有数据，而shutdown() 会等输出缓冲区中的数据传输完毕再发送FIN包。也就意味着，调用 close()/closesocket() 将丢失输出缓冲区中的数据，而调用 shutdown() 不会。

五、socket文件传输功能的实现

我们来完成 socket 文件传输程序，这是一个非常实用的例子。要实现的功能为：client 从 server 下载一个文件并保存到本地。  
编写这个程序需要注意两个问题：  
1) 文件大小不确定，有可能比缓冲区大很多，调用一次 write()/send() 函数不能完成文件内容的发送。接收数据时也会遇到同样的情况。  
要解决这个问题，可以使用 while 循环，例如：**\[cpp\]** [view plain][] [copy][view plain]

1.  //Server 代码  
2.  int nCount;  
3.  while( (nCount = fread(buffer, 1, BUF\_SIZE, fp)) > 0 )\{  
4.      send(sock, buffer, nCount, 0);  
5.  \}  
6.  //Client 代码  
7.  int nCount;  
8.  while( (nCount = recv(clntSock, buffer, BUF\_SIZE, 0)) > 0 )\{  
9.      fwrite(buffer, nCount, 1, fp);  
10. \}

对于 Server 端的代码，当读取到文件末尾，fread() 会返回 0，结束循环。  
  
对于 Client 端代码，有一个关键的问题，就是文件传输完毕后让 recv() 返回 0，结束 while 循环。

> 注意：读取完缓冲区中的数据 recv() 并不会返回 0，而是被阻塞，直到缓冲区中再次有数据。

2) Client 端如何判断文件接收完毕，也就是上面提到的问题——何时结束 while 循环。  
最简单的结束 while 循环的方法当然是文件接收完毕后让 recv() 函数返回 0，那么，如何让 recv() 返回 0 呢？recv() 返回 0 的唯一时机就是收到FIN包时。  
FIN 包表示数据传输完毕，计算机收到 FIN 包后就知道对方不会再向自己传输数据，当调用 read()/recv() 函数时，如果缓冲区中没有数据，就会返回 0，表示读到了”socket文件的末尾“。  
这里我们调用 shutdown() 来发送FIN包：server 端直接调用 close()/closesocket() 会使输出缓冲区中的数据失效，文件内容很有可能没有传输完毕连接就断开了，而调用 shutdown() 会等待输出缓冲区中的数据传输完毕。  
本节以Windows为例演示文件传输功能，Linux与此类似，不再赘述。请看下面完整的代码。  
服务器端 server.cpp：**\[cpp\]** [view plain][] [copy][view plain]

1.  \#include <stdio.h>  
2.  \#include <stdlib.h>  
3.  \#include <winsock2.h>  
4.  \#pragma comment (lib, "ws2\_32.lib")  //加载 ws2\_32.dll  
5.    
6.  \#define BUF\_SIZE 1024  
7.    
8.  int main()\{  
9.      //先检查文件是否存在  
10.     char \*filename = "D:\\\\send.avi";  //文件名  
11.     FILE \*fp = fopen(filename, "rb");  //以二进制方式打开文件  
12.     if(fp == NULL)\{  
13.         printf("Cannot open file, press any key to exit!\\n");  
14.         system("pause");  
15.         exit(0);  
16.     \}  
17.   
18.     WSADATA wsaData;  
19.     WSAStartup( MAKEWORD(2, 2), &wsaData);  
20.     SOCKET servSock = socket(AF\_INET, SOCK\_STREAM, 0);  
21.   
22.     sockaddr\_in sockAddr;  
23.     memset(&sockAddr, 0, sizeof(sockAddr));  
24.     sockAddr.sin\_family = PF\_INET;  
25.     sockAddr.sin\_addr.s\_addr = inet\_addr("127.0.0.1");  
26.     sockAddr.sin\_port = htons(1234);  
27.     bind(servSock, (SOCKADDR\*)&sockAddr, sizeof(SOCKADDR));  
28.     listen(servSock, 20);  
29.   
30.     SOCKADDR clntAddr;  
31.     int nSize = sizeof(SOCKADDR);  
32.     SOCKET clntSock = accept(servSock, (SOCKADDR\*)&clntAddr, &nSize);  
33.   
34.     //循环发送数据，直到文件结尾  
35.     char buffer\[BUF\_SIZE\] = \{0\};  //缓冲区  
36.     int nCount;  
37.     while( (nCount = fread(buffer, 1, BUF\_SIZE, fp)) > 0 )\{  
38.         send(clntSock, buffer, nCount, 0);  
39.     \}  
40.   
41.     shutdown(clntSock, SD\_SEND);  //文件读取完毕，断开输出流，向客户端发送FIN包  
42.     recv(clntSock, buffer, BUF\_SIZE, 0);  //阻塞，等待客户端接收完毕  
43.   
44.     fclose(fp);  
45.     closesocket(clntSock);  
46.     closesocket(servSock);  
47.     WSACleanup();  
48.   
49.     system("pause");  
50.     return 0;  
51. \}

客户端代码：**\[cpp\]** [view plain][] [copy][view plain]

1.  \#include <stdio.h>  
2.  \#include <stdlib.h>  
3.  \#include <WinSock2.h>  
4.  \#pragma comment(lib, "ws2\_32.lib")  
5.    
6.  \#define BUF\_SIZE 1024  
7.    
8.  int main()\{  
9.      //先输入文件名，看文件是否能创建成功  
10.     char filename\[100\] = \{0\};  //文件名  
11.     printf("Input filename to save: ");  
12.     gets(filename);  
13.     FILE \*fp = fopen(filename, "wb");  //以二进制方式打开（创建）文件  
14.     if(fp == NULL)\{  
15.         printf("Cannot open file, press any key to exit!\\n");  
16.         system("pause");  
17.         exit(0);  
18.     \}  
19.   
20.     WSADATA wsaData;  
21.     WSAStartup(MAKEWORD(2, 2), &wsaData);  
22.     SOCKET sock = socket(PF\_INET, SOCK\_STREAM, IPPROTO\_TCP);  
23.   
24.     sockaddr\_in sockAddr;  
25.     memset(&sockAddr, 0, sizeof(sockAddr));  
26.     sockAddr.sin\_family = PF\_INET;  
27.     sockAddr.sin\_addr.s\_addr = inet\_addr("127.0.0.1");  
28.     sockAddr.sin\_port = htons(1234);  
29.     connect(sock, (SOCKADDR\*)&sockAddr, sizeof(SOCKADDR));  
30.   
31.     //循环接收数据，直到文件传输完毕  
32.     char buffer\[BUF\_SIZE\] = \{0\};  //文件缓冲区  
33.     int nCount;  
34.     while( (nCount = recv(sock, buffer, BUF\_SIZE, 0)) > 0 )\{  
35.         fwrite(buffer, nCount, 1, fp);  
36.     \}  
37.     puts("File transfer success!");  
38.   
39.     //文件接收完毕后直接关闭套接字，无需调用shutdown()  
40.     fclose(fp);  
41.     closesocket(sock);  
42.     WSACleanup();  
43.     system("pause");  
44.     return 0;  
45. \}

在D盘中准备好send.avi文件，先运行 server，再运行 client：  
Input filename to save: D:\\\\recv.avi↙  
//稍等片刻后  
File transfer success!  
打开D盘就可以看到 recv.avi，大小和 send.avi 相同，可以正常播放。  
注意 server.cpp 第42行代码，recv() 并没有接收到 client 端的数据，当 client 端调用 closesocket() 后，server 端会收到FIN包，recv() 就会返回，后面的代码继续执行。

软件-注重思想、逻辑

[1-151020115S23R.jpg]: /images/20220517/1c3539baac674fbe9c012ba289a8404f.png
[1-151020132J32G.jpg]: /images/20220517/5fbfa90c985e4230b6be1fcd93843964.png
[1-15110510394G48.jpg]: /images/20220517/4f2a3f95e5384da2ad86cb83339bd46f.png
[1-151106134A4196.jpg]: /images/20220517/0eba86b4f08d4d74871ce54058bf8251.png
[1-15102015224Wc.jpg]: /images/20220517/6746550727ea406793409f9e40f065df.png
[1-15102016331RI.jpg]: /images/20220517/0e508427261647b9b756a4051729afbd.png
[view plain]: http://blog.csdn.net/Ctrl_qun/article/details/52518479#