网络编程Socket之TCP之close/shutdown详解

close：

当套接字的引用计数为0的时候才会引发TCP的四分组连接终止序列；

 

shutdown：

不用管套接字的引用计数就激发TCP的正常连接终止序列；

这里由一个SO_LINGER套接字选项

struct linger {

     int l_onoff; /* 0 = off, nozero = on */

     int l_linger; /* linger time，POSIX specifies units as seconds */

};

shutdown：SHUT_RD

关闭连接的读这一半，进程不能再对这样的套接字调用任何读操作；

在套接字上不能再发出接收请求，进程仍可往套接字发送数据，套接字接收缓冲区中所有数据被丢弃，再接收到的任何数据由TCP丢弃，对套接字发送缓冲区没有任何影响；

程序模拟：

client：

[cpp]  view plain copy

1. struct sockaddr_in serverAdd;  
2.       
3.     bzero(&serverAdd, sizeof(serverAdd));  
4.     serverAdd.sin_family = AF_INET;  
5.     serverAdd.sin_addr.s_addr = inet_addr(SERV_ADDR);  
6.     serverAdd.sin_port = htons(SERV_PORT);  
7.       
8.     int connfd = socket(AF_INET, SOCK_STREAM, 0);  
9.       
10.     int connResult = connect(connfd, (struct sockaddr *)&serverAdd, sizeof(serverAdd));  
11.     if (connResult < 0) {  
12.         printf("连接失败\n");  
13.         close(connfd);  
14.         return;  
15.     }  
16.     else  
17.     {  
18.         printf("连接成功\n");  
19.     }  
20.       
21.     ssize_t writeLen;  
22.   
23.     char sendMsg[5000] = {0};  
24.     unsigned long long totalSize = 0;  
25.     
26.     if (1) {  
27.   
28.         writeLen = write(connfd, sendMsg, sizeof(sendMsg));  
29.         if (writeLen < 0) {  
30.             printf("发送失败 errno = %d\n",errno);  
31.             return;  
32.         }  
33.         else  
34.         {  
35.             totalSize += writeLen;  
36.             printf("发送成功 totalSize = %zd\n",totalSize);  
37.         }  
38.         sleep(20);  
39.           
40.     }  

server:

[cpp]  view plain copy

1. #define SERV_PORT 8000  
2.   
3. int main(int argc, const char * argv[])  
4. {  
5.   
6.     struct sockaddr_in serverAdd;  
7.     struct sockaddr_in clientAdd;  
8.       
9.     bzero(&serverAdd, sizeof(serverAdd));  
10.     serverAdd.sin_family = AF_INET;  
11.     serverAdd.sin_addr.s_addr = htonl(INADDR_ANY);  
12.     serverAdd.sin_port = htons(SERV_PORT);  
13.       
14.     socklen_t clientAddrLen;  
15.       
16.     int listenfd = socket(AF_INET, SOCK_STREAM, 0);  
17.     int yes = 1;  
18.     setsockopt(listenfd,  
19.                SOL_SOCKET, SO_REUSEADDR,  
20.                (void *)&yes, sizeof(yes));  
21.       
22.     if (listenfd < 0) {  
23.         printf("创建socket失败\n");  
24.         return -1;  
25.     }  
26.       
27.     int bindResult = bind(listenfd, (struct sockaddr *)&serverAdd, sizeof(serverAdd));  
28.     if (bindResult < 0) {  
29.         printf("绑定端口失败\n");  
30.         close(listenfd);  
31.         return -1;  
32.     }  
33.       
34.     listen(listenfd, 20);  
35.       
36.     int connfd;  
37.     unsigned char recvMsg[246988];  
38.     unsigned long long totalSize = 0;  
39.       
40.     clientAddrLen = sizeof(clientAdd);  
41.     connfd = accept(listenfd,(struct sockaddr *)&clientAdd,&clientAddrLen);  
42.     if (connfd < 0) {  
43.         printf("连接失败\n");  
44.         return -1;  
45.     }  
46.     else{  
47. //        这里我们用于测试，只接收一个连接  
48.         close(listenfd);  
49.     }  
50.       
51.     shutdown(connfd,SHUT_RD);  
52.   
53.     while (1) {  
54.         ssize_t readLen = read(connfd, recvMsg, sizeof(recvMsg));  
55.           
56.         if (readLen < 0) {  
57.             printf("读取失败 errno = %d\n",errno);  
58.             close(connfd);  
59.             return -1;  
60.         }  
61.         else if (readLen == 0) {  
62.             printf("读取完成 totalSize = %llu\n",totalSize);  
63.             close(connfd);  
64.             return -1;  
65.         }  
66.         else  
67.         {  
68.             totalSize += readLen;  
69.             printf("readLen:%ld\n",readLen);  
70.         }  
71.   
72.     }  
73.       
74.     return 0;  
75. }  

打印信息：

client：

连接成功

发送成功 totalSize = 5000

server：

读取完成 totalSize = 0

是因为读关闭了，套接字接收缓冲区的数据直接被丢弃掉了，如果将服务端的shutdiwn替换成close会如下

读取失败 errno = 9

#defineEBADF 9/* Bad file descriptor */

说明：如果服务端调用shutdown关闭读之后，客户端再往已经收到RST分节的服务端进行write操作，会引发错误导致程序终止，RST详解里面有讲到

抓包信息：

shutdown：SHUT_WR

关闭连接的写这一半，进程不能再对这样的套接字调用任何写操作；

在套接字上不能再发出发送请求，进程仍可从套接字接收数据，套接字发送缓冲区中的内容被发送到对端，后跟正常的TCP连接终止序列（即发送FIN），对套接字接收缓冲区无任何影响；

程序模拟：

client：

[cpp]  view plain copy

1. struct sockaddr_in serverAdd;  
2.       
3.     bzero(&serverAdd, sizeof(serverAdd));  
4.     serverAdd.sin_family = AF_INET;  
5.     serverAdd.sin_addr.s_addr = inet_addr(SERV_ADDR);  
6.     serverAdd.sin_port = htons(SERV_PORT);  
7.       
8.     int connfd = socket(AF_INET, SOCK_STREAM, 0);  
9.       
10.     int connResult = connect(connfd, (struct sockaddr *)&serverAdd, sizeof(serverAdd));  
11.     if (connResult < 0) {  
12.         printf("连接失败\n");  
13.         close(connfd);  
14.         return;  
15.     }  
16.     else  
17.     {  
18.         printf("连接成功\n");  
19.     }  
20.       
21.     ssize_t writeLen;  
22.   
23.     char sendMsg[200000] = {0};  
24.     unsigned long long totalSize = 0;  
25.    
26.     if (1) {  
27.   
28.         writeLen = write(connfd, sendMsg, sizeof(sendMsg));  
29.         if (writeLen < 0) {  
30.             printf("发送失败 errno = %d\n",errno);  
31.             return;  
32.         }  
33.         else  
34.         {  
35.             totalSize += writeLen;  
36.             printf("发送成功 totalSize = %zd\n",totalSize);  
37.         }  
38.         shutdown(connfd,SHUT_WR);  
39.         sleep(20);  
40.   
41.     }  

server：

[cpp]  view plain copy

1. int main(int argc, const char * argv[])  
2. {  
3.   
4.     struct sockaddr_in serverAdd;  
5.     struct sockaddr_in clientAdd;  
6.       
7.     bzero(&serverAdd, sizeof(serverAdd));  
8.     serverAdd.sin_family = AF_INET;  
9.     serverAdd.sin_addr.s_addr = htonl(INADDR_ANY);  
10.     serverAdd.sin_port = htons(SERV_PORT);  
11.       
12.     socklen_t clientAddrLen;  
13.       
14.     int listenfd = socket(AF_INET, SOCK_STREAM, 0);  
15.     int yes = 1;  
16.     setsockopt(listenfd,  
17.                SOL_SOCKET, SO_REUSEADDR,  
18.                (void *)&yes, sizeof(yes));  
19.       
20.     if (listenfd < 0) {  
21.         printf("创建socket失败\n");  
22.         return -1;  
23.     }  
24.       
25.     int bindResult = bind(listenfd, (struct sockaddr *)&serverAdd, sizeof(serverAdd));  
26.     if (bindResult < 0) {  
27.         printf("绑定端口失败\n");  
28.         close(listenfd);  
29.         return -1;  
30.     }  
31.       
32.     listen(listenfd, 20);  
33.       
34.     int connfd;  
35.     unsigned char recvMsg[246988];  
36.     unsigned long long totalSize = 0;  
37.       
38.     clientAddrLen = sizeof(clientAdd);  
39.     connfd = accept(listenfd,(struct sockaddr *)&clientAdd,&clientAddrLen);  
40.     if (connfd < 0) {  
41.         printf("连接失败\n");  
42.         return -1;  
43.     }  
44.     else{  
45. //        这里我们用于测试，只接收一个连接  
46.         close(listenfd);  
47.     }  
48.       
49.     while (1) {  
50.         ssize_t readLen = read(connfd, recvMsg, sizeof(recvMsg));  
51.           
52.         if (readLen < 0) {  
53.             printf("读取失败 errno = %d\n",errno);  
54.             close(connfd);  
55.             return -1;  
56.         }  
57.         else if (readLen == 0) {  
58.             printf("读取完成 totalSize = %llu\n",totalSize);  
59.             close(connfd);  
60.             return -1;  
61.         }  
62.         else  
63.         {  
64.             totalSize += readLen;  
65.             printf("readLen:%ld\n",readLen);  
66.         }  
67.   
68.     }  
69.       
70.     return 0;  
71. }  

打印信息：

client：

连接成功

发送成功 totalSize = 200000

server：

readLen:1448

readLen:1448

readLen:1448

readLen:1448

... ...

readLen:1448

readLen:1448

readLen:3072

读取完成 totalSize = 200000

说明：客户端发送字节200000的大小大于TCP套接字发送缓冲区的大小，数据全部成功送达服务端，但是在调用shutdown关闭写之后不能再调用write方法，会引起错误终止程序，这里和上面的关闭读有差别；

shutdown：SHUT_RDWR

关闭连接的读和写；

close：l_onoff ＝ 0（默认情况）：

在套接字上不能再发出发送或接收请求，套接字发送缓冲区中的内容被发送到对端，如果描述符引用计数变为0，在发送完发送缓冲区的数据后，跟以正常的TCP连接终止序列（即发送FIN），套接字接收缓冲区中的内容被丢弃；

程序模拟：

client：

[cpp]  view plain copy

1. struct sockaddr_in serverAdd;  
2.       
3.     bzero(&serverAdd, sizeof(serverAdd));  
4.     serverAdd.sin_family = AF_INET;  
5.     serverAdd.sin_addr.s_addr = inet_addr(SERV_ADDR);  
6.     serverAdd.sin_port = htons(SERV_PORT);  
7.       
8.     int connfd = socket(AF_INET, SOCK_STREAM, 0);  
9.       
10.     int connResult = connect(connfd, (struct sockaddr *)&serverAdd, sizeof(serverAdd));  
11.     if (connResult < 0) {  
12.         printf("连接失败\n");  
13.         close(connfd);  
14.         return;  
15.     }  
16.       
17.     ssize_t writeLen;  
18.     char sendMsg[5000] = {0};  
19.     for (int i = 0 ; i<sizeof(sendMsg); i++) {  
20.         sendMsg[i] = 'a';  
21.     }  
22.     while (1) {  
23.           
24.         writeLen = write(connfd, sendMsg, sizeof(sendMsg));  
25.         if (writeLen < 0) {  
26.             printf("发送失败\n");  
27.             return;  
28.         }  
29.         else  
30.         {  
31.             printf("发送成功 writeLen = %zd\n",writeLen);  
32.         }  
33.                  
34.         close(connfd);  
35.           
36.         break;  
37.     }  

server：

[cpp]  view plain copy

1. #define SERV_PORT 8000  
2.   
3. int main(int argc, const char * argv[])  
4. {  
5.   
6.     struct sockaddr_in serverAdd;  
7.     struct sockaddr_in clientAdd;  
8.       
9.     bzero(&serverAdd, sizeof(serverAdd));  
10.     serverAdd.sin_family = AF_INET;  
11.     serverAdd.sin_addr.s_addr = htonl(INADDR_ANY);  
12.     serverAdd.sin_port = htons(SERV_PORT);  
13.       
14.     socklen_t clientAddrLen;  
15.       
16.     int listenfd = socket(AF_INET, SOCK_STREAM, 0);  
17.     int yes = 1;  
18.     setsockopt(listenfd,  
19.                SOL_SOCKET, SO_REUSEADDR,  
20.                (void *)&yes, sizeof(yes));  
21.       
22.     if (listenfd < 0) {  
23.         printf("创建socket失败\n");  
24.         return -1;  
25.     }  
26.       
27.     int bindResult = bind(listenfd, (struct sockaddr *)&serverAdd, sizeof(serverAdd));  
28.     if (bindResult < 0) {  
29.         printf("绑定端口失败\n");  
30.         close(listenfd);  
31.         return -1;  
32.     }  
33.       
34.     listen(listenfd, 20);  
35.       
36.     int connfd;  
37.     unsigned char recvMsg[246988];  
38.     unsigned long long totalSize = 0;  
39.       
40.     clientAddrLen = sizeof(clientAdd);  
41.     connfd = accept(listenfd,(struct sockaddr *)&clientAdd,&clientAddrLen);  
42.     if (connfd < 0) {  
43.         printf("连接失败\n");  
44.         return -1;  
45.     }  
46.     else{  
47. //        这里我们用于测试，只接收一个连接  
48.         close(listenfd);  
49.     }  
50.       
51.     sleep(1);  
52.     close(connfd);  
53.     while (1)  
54.     {  
55.         ssize_t readLen = read(connfd, recvMsg, sizeof(recvMsg));  
56.           
57.         if (readLen < 0) {  
58.             printf("读取失败\n");  
59.             break;  
60.         }  
61.         else if (readLen == 0) {  
62.             printf("读取完成 totalSize = %llu\n",totalSize);  
63.             break;  
64.         }  
65.         else  
66.         {  
67.             totalSize += readLen;  
68.             printf("readLen:%ld\n",readLen);  
69.         }  
70.     }  
71.       
72.     return 0;  
73. }  

先运行服务端，再运行客户端，打印信息如下：

client：

发送成功 writeLen = 5000

server：

读取失败

抓包信息：

说明：通过抓包可以看出客户端的5000字节的数据都成功发送到服务端，服务器里面有一秒的休眠才关闭连接就是为了接收完这些数据，关闭连接以后再来通过read读取接收缓冲区的数据却读取失败，说明已经被内核丢弃了，而客户端的数据是已经成功写到发送缓冲区，即使关闭连接，发送缓冲区的数据不会被丢弃，会正常发送到服务器，发送完成以后，接着发送终止连接的第一个FIN分节；

close：l_onoff ＝ 1，l_linger ＝ 0：

在套接字上不能再发出发送或接收请求，如果描述符引用计数变为0，RST被发送到对端，连接的状态被置为CLOSED（没有TIME_WAIT状态），套接字发送缓冲区和接收缓冲区中的内容被丢弃；

模拟程序（套接字发送缓冲区数据被丢弃）：

client：

[cpp]  view plain copy

1. struct sockaddr_in serverAdd;  
2.   
3. bzero(&serverAdd, sizeof(serverAdd));  
4. serverAdd.sin_family = AF_INET;  
5. serverAdd.sin_addr.s_addr = inet_addr(SERV_ADDR);  
6. serverAdd.sin_port = htons(SERV_PORT);  
7.   
8. int connfd = socket(AF_INET, SOCK_STREAM, 0);  
9.   
10. int connResult = connect(connfd, (struct sockaddr *)&serverAdd, sizeof(serverAdd));  
11. if (connResult < 0) {  
12.     printf("连接失败\n");  
13.     close(connfd);  
14.     return;  
15. }  
16. else  
17. {  
18.     printf("连接成功\n");  
19. }  
20.   
21. ssize_t writeLen;  
22. char sendMsg[200000] = {0};  
23. unsigned long long totalSize = 0;  
24.   
25. struct linger so_linger;  
26.   
27. so_linger.l_onoff = 1;  
28. so_linger.l_linger = 0;  
29. setsockopt(connfd,  
30.            SOL_SOCKET,  
31.            SO_LINGER,  
32.            &so_linger,  
33.            sizeof so_linger);  
34.   
35.   
36. if (1) {  
37.       
38.     writeLen = write(connfd, sendMsg, sizeof(sendMsg));  
39.     if (writeLen < 0) {  
40.         printf("发送失败 errno = %d\n",errno);  
41.         return;  
42.     }  
43.     else  
44.     {  
45.         totalSize += writeLen;  
46.         printf("发送成功 totalSize = %zd\n",totalSize);  
47.     }  
48.   
49.     close(connfd);  
50.       
51. }  

server：

[cpp]  view plain copy

1. int main(int argc, const char * argv[])  
2. {  
3.   
4.     struct sockaddr_in serverAdd;  
5.     struct sockaddr_in clientAdd;  
6.       
7.     bzero(&serverAdd, sizeof(serverAdd));  
8.     serverAdd.sin_family = AF_INET;  
9.     serverAdd.sin_addr.s_addr = htonl(INADDR_ANY);  
10.     serverAdd.sin_port = htons(SERV_PORT);  
11.       
12.     socklen_t clientAddrLen;  
13.       
14.     int listenfd = socket(AF_INET, SOCK_STREAM, 0);  
15.     int yes = 1;  
16.     setsockopt(listenfd,  
17.                SOL_SOCKET, SO_REUSEADDR,  
18.                (void *)&yes, sizeof(yes));  
19.       
20.     if (listenfd < 0) {  
21.         printf("创建socket失败\n");  
22.         return -1;  
23.     }  
24.       
25.     int bindResult = bind(listenfd, (struct sockaddr *)&serverAdd, sizeof(serverAdd));  
26.     if (bindResult < 0) {  
27.         printf("绑定端口失败\n");  
28.         close(listenfd);  
29.         return -1;  
30.     }  
31.       
32.     listen(listenfd, 20);  
33.       
34.     int connfd;  
35.     unsigned char recvMsg[246988];  
36.     unsigned long long totalSize = 0;  
37.       
38.     clientAddrLen = sizeof(clientAdd);  
39.     connfd = accept(listenfd,(struct sockaddr *)&clientAdd,&clientAddrLen);  
40.     if (connfd < 0) {  
41.         printf("连接失败\n");  
42.         return -1;  
43.     }  
44.     else{  
45. //        这里我们用于测试，只接收一个连接  
46.         close(listenfd);  
47.     }  
48.       
49.     while (1) {  
50.         sleep(1);  
51.         ssize_t readLen = read(connfd, recvMsg, sizeof(recvMsg));  
52.           
53.         if (readLen < 0) {  
54.             printf("读取失败 errno = %d\n",errno);  
55.             close(connfd);  
56.             return -1;  
57.         }  
58.         else if (readLen == 0) {  
59.             printf("读取完成 totalSize = %llu\n",totalSize);  
60.             close(connfd);  
61.             return -1;  
62.         }  
63.         else  
64.         {  
65.             totalSize += readLen;  
66.             printf("readLen:%ld\n",readLen);  
67.         }  
68.   
69.     }  
70.       
71.     return 0;  
72. }  

打印信息：

client：

连接成功

发送成功 totalSize = 200000

server：

readLen:91224

读取失败 errno = 54

抓包信息：

说明：调用close的时候RST分节发送出去，携带89777到91224字节的数据，然后丢弃发送缓冲区中的数据，因此服务器再向已经收到RST分节的套接字read失败，返回错误码：

#define ECONNRESET54/* Connection reset by peer */

再看下面的模拟程序（套接字接收缓冲区数据被丢弃）：

client：

[cpp]  view plain copy

1. struct sockaddr_in serverAdd;  
2.       
3.     bzero(&serverAdd, sizeof(serverAdd));  
4.     serverAdd.sin_family = AF_INET;  
5.     serverAdd.sin_addr.s_addr = inet_addr(SERV_ADDR);  
6.     serverAdd.sin_port = htons(SERV_PORT);  
7.       
8.     int connfd = socket(AF_INET, SOCK_STREAM, 0);  
9.       
10.     int connResult = connect(connfd, (struct sockaddr *)&serverAdd, sizeof(serverAdd));  
11.     if (connResult < 0) {  
12.         printf("连接失败\n");  
13.         close(connfd);  
14.         return;  
15.     }  
16.     else  
17.     {  
18.         printf("连接成功\n");  
19.     }  
20.       
21.     ssize_t writeLen;  
22.   
23.     char sendMsg[200000] = {0};  
24.     unsigned long long totalSize = 0;  
25.   
26.     while (1) {  
27.           
28.         writeLen = write(connfd, sendMsg, sizeof(sendMsg));  
29.         if (writeLen < 0) {  
30.             printf("发送失败 errno = %d\n",errno);  
31.             return;  
32.         }  
33.         else  
34.         {  
35.             totalSize += writeLen;  
36.             printf("发送成功 totalSize = %zd\n",totalSize);  
37.         }  
38.           
39.     }  

server：

[cpp]  view plain copy

1. int main(int argc, const char * argv[])  
2. {  
3.   
4.     struct sockaddr_in serverAdd;  
5.     struct sockaddr_in clientAdd;  
6.       
7.     bzero(&serverAdd, sizeof(serverAdd));  
8.     serverAdd.sin_family = AF_INET;  
9.     serverAdd.sin_addr.s_addr = htonl(INADDR_ANY);  
10.     serverAdd.sin_port = htons(SERV_PORT);  
11.       
12.     socklen_t clientAddrLen;  
13.       
14.     int listenfd = socket(AF_INET, SOCK_STREAM, 0);  
15.     int yes = 1;  
16.     setsockopt(listenfd,  
17.                SOL_SOCKET, SO_REUSEADDR,  
18.                (void *)&yes, sizeof(yes));  
19.       
20.     if (listenfd < 0) {  
21.         printf("创建socket失败\n");  
22.         return -1;  
23.     }  
24.       
25.     int bindResult = bind(listenfd, (struct sockaddr *)&serverAdd, sizeof(serverAdd));  
26.     if (bindResult < 0) {  
27.         printf("绑定端口失败\n");  
28.         close(listenfd);  
29.         return -1;  
30.     }  
31.       
32.     listen(listenfd, 20);  
33.       
34.     int connfd;  
35.     unsigned char recvMsg[246988];  
36.     unsigned long long totalSize = 0;  
37.       
38.     clientAddrLen = sizeof(clientAdd);  
39.     connfd = accept(listenfd,(struct sockaddr *)&clientAdd,&clientAddrLen);  
40.     if (connfd < 0) {  
41.         printf("连接失败\n");  
42.         return -1;  
43.     }  
44.     else{  
45. //        这里我们用于测试，只接收一个连接  
46.         close(listenfd);  
47.     }  
48.       
49.       
50.     struct linger so_linger;  
51.       
52.     so_linger.l_onoff = 1;  
53.     so_linger.l_linger = 0;  
54.     setsockopt(connfd,  
55.                SOL_SOCKET,  
56.                SO_LINGER,  
57.                &so_linger,  
58.                sizeof so_linger);  
59.       
60.     while (1) {  
61.         sleep(1);  
62.         ssize_t readLen = read(connfd, recvMsg, sizeof(recvMsg));  
63.           
64.         if (readLen < 0) {  
65.             printf("读取失败 errno = %d\n",errno);  
66.             close(connfd);  
67.             return -1;  
68.         }  
69.         else if (readLen == 0) {  
70.             printf("读取完成 totalSize = %llu\n",totalSize);  
71.             close(connfd);  
72.             return -1;  
73.         }  
74.         else  
75.         {  
76.             totalSize += readLen;  
77.             printf("readLen:%ld\n",readLen);  
78.         }  
79.         close(connfd);  
80.   
81.     }  
82.       
83.     return 0;  
84. }  

打印信息：

client：

连接成功

发送成功 totalSize = 200000

发送成功 totalSize = 400000

发送成功 totalSize = 600000

(lldb) 

然后程序返回错误被终止

server：

readLen:246988

读取失败 errno = 9

#define EBADF9/* Bad file descriptor */

抓包信息：

说明：服务端调用close以后直接发送RST分节，接收缓冲区数据被丢弃，客户端向已经收到RST分节的套接字write会返回错误终止程序

close：l_onoff ＝ 1，l_linger  !＝ 0：

在套接字上不能再发出发送或接收请求，套接字发送缓冲区中的内容被发送到对端，如果描述符引用计数变为0，在发送完发送缓冲区的数据后，跟以正常的TCP连接终止序列（即发送FIN），套接字接收缓冲区中的内容被丢弃，如果在连接变为CLOSED状态前延滞时间到，那么close返回EWOULDBLOCK错误；

模拟程序：

client：

[cpp]  view plain copy

1. struct sockaddr_in serverAdd;  
2.       
3.     bzero(&serverAdd, sizeof(serverAdd));  
4.     serverAdd.sin_family = AF_INET;  
5.     serverAdd.sin_addr.s_addr = inet_addr(SERV_ADDR);  
6.     serverAdd.sin_port = htons(SERV_PORT);  
7.       
8.     int connfd = socket(AF_INET, SOCK_STREAM, 0);  
9.       
10.     int connResult = connect(connfd, (struct sockaddr *)&serverAdd, sizeof(serverAdd));  
11.     if (connResult < 0) {  
12.         printf("连接失败\n");  
13.         close(connfd);  
14.         return;  
15.     }  
16.     else  
17.     {  
18.         printf("连接成功\n");  
19.     }  
20.       
21.     ssize_t writeLen;  
22.   
23.     char sendMsg[200000] = {0};  
24.     unsigned long long totalSize = 0;  
25.   
26.     struct linger so_linger;  
27.       
28.     so_linger.l_onoff = 1;  
29.     so_linger.l_linger = 3;  
30.     setsockopt(connfd,  
31.                SOL_SOCKET,  
32.                SO_LINGER,  
33.                &so_linger,  
34.                sizeof so_linger);  
35.   
36.       
37.     if (1) {  
38.   
39.         writeLen = write(connfd, sendMsg, sizeof(sendMsg));  
40.         if (writeLen < 0) {  
41.             printf("发送失败 errno = %d\n",errno);  
42.             return;  
43.         }  
44.         else  
45.         {  
46.             totalSize += writeLen;  
47.             printf("发送成功 totalSize = %zd\n",totalSize);  
48.         }  
49.   
50.         int cr = close(connfd);  
51.         if (cr < 0) {  
52.             printf("失败 errno = %d\n",errno);  
53.         }  
54.   
55.     }  

server：

[cpp]  view plain copy

1. int main(int argc, const char * argv[])  
2. {  
3.   
4.     struct sockaddr_in serverAdd;  
5.     struct sockaddr_in clientAdd;  
6.       
7.     bzero(&serverAdd, sizeof(serverAdd));  
8.     serverAdd.sin_family = AF_INET;  
9.     serverAdd.sin_addr.s_addr = htonl(INADDR_ANY);  
10.     serverAdd.sin_port = htons(SERV_PORT);  
11.       
12.     socklen_t clientAddrLen;  
13.       
14.     int listenfd = socket(AF_INET, SOCK_STREAM, 0);  
15.     int yes = 1;  
16.     setsockopt(listenfd,  
17.                SOL_SOCKET, SO_REUSEADDR,  
18.                (void *)&yes, sizeof(yes));  
19.       
20.     if (listenfd < 0) {  
21.         printf("创建socket失败\n");  
22.         return -1;  
23.     }  
24.       
25.     int bindResult = bind(listenfd, (struct sockaddr *)&serverAdd, sizeof(serverAdd));  
26.     if (bindResult < 0) {  
27.         printf("绑定端口失败\n");  
28.         close(listenfd);  
29.         return -1;  
30.     }  
31.       
32.     listen(listenfd, 20);  
33.       
34.     int connfd;  
35.     unsigned char recvMsg[20000];  
36.     unsigned long long totalSize = 0;  
37.       
38.     clientAddrLen = sizeof(clientAdd);  
39.     connfd = accept(listenfd,(struct sockaddr *)&clientAdd,&clientAddrLen);  
40.     if (connfd < 0) {  
41.         printf("连接失败\n");  
42.         return -1;  
43.     }  
44.     else{  
45. //        这里我们用于测试，只接收一个连接  
46.         close(listenfd);  
47.     }  
48.       
49.     while (1) {  
50.         sleep(1);  
51.         ssize_t readLen = read(connfd, recvMsg, sizeof(recvMsg));  
52.           
53.         if (readLen < 0) {  
54.             printf("读取失败 errno = %d\n",errno);  
55.             close(connfd);  
56.             return -1;  
57.         }  
58.         else if (readLen == 0) {  
59.             printf("读取完成 totalSize = %llu\n",totalSize);  
60.             close(connfd);  
61.             return -1;  
62.         }  
63.         else  
64.         {  
65.             totalSize += readLen;  
66.             printf("readLen:%ld\n",readLen);  
67.         }  
68.           
69.   
70.     }  
71.       
72.     return 0;  
73. }  

打印信息：

client：

连接成功

发送成功 totalSize = 200000

server：

readLen:20000

... ...

readLen:20000

读取完成 totalSize = 200000

抓包信息：

说明：数据成功发送，且发送正常的FIN分节

现在我们看看对于不同情况的close的返回情况和可能遇到的一些问题：

1.默认操作的close

说明： 我们已经知道write操作返回成功只能说明数据已经发送到套接字的发送缓冲区，不能代表对端已经成功收到数据，close的默认返回成功也只是成功发出了一个FIN分节，也不代表对端已经确认

问题1： 如果中途网络发生故障，很有可能服务端接收不到这个来自客户端的FIN分节；

问题2： 假设服务器忙，那么来自客户端的数据由TCP加入到套接字接收缓冲区，下一个FIN分节也被加入到套接字接收缓冲区，然后等待处理，如果正好此时服务器应用进程崩溃掉，那么这些数据就丢失掉了，服务器并没有真正收到，而客户端也永远不会知道；

2.设置SO_LINGER套接字选项且l_linger为正值时的close

说明： 这种情况下客户的close要到它的数据和FIN已经被服务器的TCP确认以后才会返回；

问题： 同上问题2

3.设置SO_LINGER套接字选项且l_linger为偏小正值时的close

说明： 在服务端的确认到达之前，SO_LINGER套接字选项设置的延滞时间到，close将会返回EWOULDBLOCK错误，且套接字发送缓冲区中的任何残留数据被丢弃。

问题： 同问题2

总结： 设置SO_LINGER套接字选项以后，close的成功返回只是告诉我们先前发送的数据的FIN已经由对端TCP确认，而不能告诉我们对端应用进程是否已经读取数据，如果不设置该套接字选项，那么我们连对端TCP是否确认了数据都不知道。

解决方法：

1.使用shutdown（设置SHUT_WR）+read

说明：调用写关闭的shutdown以后发送FIN分节，然后执行read，返回0则说明服务端已经读取数据然后发送终止连接的第三个分节（FIN分节）。

2.应用级确认，可由客户端和服务端指定一个终止协议

tcp本身不提供记录结束标志，tcp是一个字节流协议，没有任何记录边界：如果应用程序需要确定记录的边界，它就要自己去实现；

参考：

《 UNIX  Network ProgrammingVolume 1, Third Edition: TheSockets Networking API 》