纪一次TCP/IP连接关闭全程

TCP/IP众所周知在连接的时候，需要经历三次握手，而在终止的时候需要经历四次（有某些是以三次实现）握手才能“完美的”终止一次TCP/IP，因为TCP/IP的可靠性导致了一种互不信任的通信模式。故非此周折；

 

TCP/IP三次握手过程。

三次握手好理解。下面是TCP/IP关闭的四次握手流程图；

 

当一方发送close的时候，则向服务器发送一个FIN报文分节。得到服务器的响应，这个时候，客户机无法再进行任何的读写，也许会存在位于客户机套接字发送缓存区的数据没有发送的问题。这个时候，可以选择设置SO_LINGER选项。将close进行限时阻塞。这个时候服务器如果进行读写的话，则读会读取到流结束符，写会导致异常抛出。

 

C++服务器代码：

1. #define LINKQ 200  
2.   
3. int main(int args,char *argc[]){  
4.     int listenfd;  
5.   
6.     listenfd=socket(AF_INET,SOCK_STREAM,0);  
7.   
8.     /**display the sock send buf size*/  
9.   
10.     int sndbufold;  
11.       
12.     socklen_t sndbufoldsize=sizeof(sndbufold);  
13.   
14.     getsockopt(listenfd,SOL_SOCKET,SO_SNDBUF,&sndbufold,&sndbufoldsize);  
15.       
16.     cout << "--" << sndbufold << "--" << endl;  
17.   
18.     sndbufold=1000;  
19.       
20.     setsockopt(listenfd,SOL_SOCKET,SO_SNDBUF,&sndbufold,sndbufoldsize);  
21.   
22.   
23.     int sndbufold2;  
24.       
25.     socklen_t sndbufoldsize2=sizeof(sndbufold2);  
26.   
27.   
28.     getsockopt(listenfd,SOL_SOCKET,SO_SNDBUF,&sndbufold2,&sndbufoldsize2);  
29.       
30.     cout << "--" << sndbufold2 << "--" << endl;  
31.   
32.   
33.     /**display the sock send buf size*/  
34.   
35.   
36.     struct sockaddr_in addr;  
37.     bzero(&addr,sizeof(addr));  
38.     addr.sin_family=AF_INET;  
39.     addr.sin_port=htons(10355);  
40.     addr.sin_addr.s_addr=htonl(INADDR_ANY);  
41.     if((bind(listenfd,(struct sockaddr *)&addr,sizeof(addr)))<0){  
42.         perror("error:");  
43.     }  
44.     listen(listenfd,LINKQ);  
45.   
46.     struct sockaddr_in clientaddr;  
47.   
48.     socklen_t clientlen;  
49.   
50.   
51.     int clientfd=accept(listenfd,(struct sockaddr *)&clientaddr,&clientlen);  
52.   
53.     int sndbufold3=200;  
54.       
55.     socklen_t sndbufoldsize3=sizeof(sndbufold3);  
56.   
57.     setsockopt(clientfd,SOL_SOCKET,SO_SNDBUF,&sndbufold3,sndbufoldsize3);  
58.   
59.     int sndbufold4;  
60.       
61.     socklen_t sndbufoldsize4=sizeof(sndbufold4);  
62.   
63.   
64.     getsockopt(listenfd,SOL_SOCKET,SO_SNDBUF,&sndbufold4,&sndbufoldsize4);  
65.   
66.     cout << "client:" << sndbufold4 <<endl;  
67.       
68.     char res[5000];  
69.   
70.     memset(res,'a',5000);  
71.   
72.   
73.     int wlen;  
74.       
75.     for(;;){  
76.         cout << "go to read" << endl <<flush;  
77.         int readsize=read(clientfd,res,100);  
78.         cout << "read back:" << readsize << endl << flush;  
79.     }  
80.       
81. }  

  

服务器主要是读从客户端中读取字节。

 

C++客户端：

1. int main(int args,char *argc[]){  
2.   
3.          int listenfd;  
4.   
5.          listenfd=socket(AF_INET,SOCK_STREAM,0);  
6.   
7.    
8.   
9.          /**display the sock send buf size*/  
10.   
11.    
12.   
13.          int sndbufold;  
14.   
15.            
16.   
17.          socklen_t sndbufoldsize=sizeof(sndbufold);  
18.   
19.    
20.   
21.          getsockopt(listenfd,SOL_SOCKET,SO_RCVBUF,&sndbufold,&sndbufoldsize);  
22.   
23.            
24.   
25.          cout << "--" << sndbufold << "--" << endl;  
26.   
27.    
28.   
29.          sndbufold=1033;  
30.   
31.            
32.   
33.          setsockopt(listenfd,SOL_SOCKET,SO_RCVBUF,&sndbufold,sndbufoldsize);  
34.   
35.    
36.   
37.    
38.   
39.     int sndbufold2;  
40.   
41.            
42.   
43.          socklen_t sndbufoldsize2=sizeof(sndbufold2);  
44.   
45.    
46.   
47.    
48.   
49.          getsockopt(listenfd,SOL_SOCKET,SO_RCVBUF,&sndbufold2,&sndbufoldsize2);  
50.   
51.            
52.   
53.          cout << "--" << sndbufold2 << "--" << endl;  
54.   
55.    
56.   
57.    
58.   
59.          /**display the sock send buf size*/  
60.   
61.    
62.   
63.    
64.   
65.          struct sockaddr_in addr;  
66.   
67.          bzero(&addr,sizeof(addr));  
68.   
69.          addr.sin_family=AF_INET;  
70.   
71.          addr.sin_port=htons(10355);  
72.   
73.          struct in_addr host;  
74.   
75.    
76.   
77.          inet_pton(AF_INET,"192.168.1.101",(void *)&(addr.sin_addr));  
78.   
79.    
80.   
81.          connect(listenfd,(struct sockaddr *)&addr,sizeof(addr));  
82.   
83.            
84.   
85.          int canread;  
86.   
87.            
88.   
89.          char getc[]="coreymylife";  
90.   
91.    
92.   
93.            
94.   
95.            
96.   
97.          for(int i=0;i<300;i++){  
98.   
99.                    write(listenfd,getc,3);  
100.   
101.          }  
102.   
103.    
104.   
105.          for(;;){  
106.   
107.                    write(listenfd,getc,3);  
108.   
109.          }  
110.   
111.            
112.   
113.          cout << "the end!" << endl << flush ;  
114.   
115. }  

 

客户端主要是持续的向服务器写入字节；

 

另外用JAVA代码进行了一个C/S程序做对比；

JAVA服务器：

 

1. package org.corey.test;  
2.   
3.    
4.   
5. import java.io.IOException;  
6.   
7. import java.io.InputStream;  
8.   
9. import java.io.OutputStream;  
10.   
11. import java.net.ServerSocket;  
12.   
13. import java.net.Socket;  
14.   
15.    
16.   
17. public class Server {  
18.   
19.     public static void main(String[] args) {  
20.   
21.        try {  
22.   
23.            ServerSocket server = new ServerSocket(10000);  
24.   
25.            Socket requestClient = server.accept();  
26.   
27.            InputStream is = requestClient.getInputStream();  
28.   
29.            while (true) {  
30.   
31.               System.out.println("begin:");  
32.   
33.               int a=is.read();  
34.   
35.               if(a==-1){  
36.   
37.                   OutputStream os=requestClient.getOutputStream();  
38.   
39.                   os.write("a".getBytes());  
40.   
41.               }  
42.   
43.               System.out.println("end:"+a);  
44.   
45.            }  
46.   
47.        } catch (IOException e) {  
48.   
49.            e.printStackTrace();  
50.   
51.        }  
52.   
53.    
54.   
55.     }  
56.   
57. }  

JAVA客户端代码:

1. package org.corey.test;  
2.   
3.    
4.   
5. import java.io.IOException;  
6.   
7. import java.io.OutputStream;  
8.   
9. import java.net.Socket;  
10.   
11. import java.net.UnknownHostException;  
12.   
13.    
14.   
15. public class Client {  
16.   
17.     public static void main(String[] args) {  
18.   
19.        try {  
20.   
21.            Socket client = new Socket("127.0.0.1", 10000);  
22.   
23.            OutputStream os = client.getOutputStream();  
24.   
25.            for (int i = 0; i < 1000; i++) {  
26.   
27.               os.write(i);  
28.   
29.            }  
30.   
31.            os.close();  
32.   
33.            client.close();  
34.   
35.        } catch (UnknownHostException e) {  
36.   
37.            e.printStackTrace();  
38.   
39.        } catch (IOException e) {  
40.   
41.            e.printStackTrace();  
42.   
43.        }  
44.   
45.     }  
46.   
47. }  

  

 

在LINUX系统中，每一个合理关闭(main执行结束)和意外关闭(SIGKILL)被系统中断的程序，都在结束的时候向远程服务器发送一个FIN分节。

 

其中四个程序分别运行在以下环境：

C++ server:Fedora

C++ client:cygwin windows

JAVA server:windows

JAVA client:windows

 

下面分别是几种关闭客户端进程的情况：

 

JAVA客户端退出

1）  非正常终止（不显示调用close）:

a)         服务器读：Connection reset异常；

b)         服务器写：socket write error；

2）  close终止：

a)         服务器读：-1，流结束符；

b)         服务器写：socket write error；

C++客户端退出

1）  非正常终止（不显示调用close）:

a)         服务器读：0，流结束符

b)         服务器写：-1 异常

2）  close终止：

a)         服务器读：0，流结束符；

b)         服务器写：-1 异常

 

TCP/IP的状态图如下：

 

状态描述：

1）  服务器启动。这个时候状态为

 

状态为：

2）  客户端连接:

客户机状态和服务器状态：

        

这个时候，我们可以用tcpdump看到两台机器中不断的发送数据，

3）关闭客户端

        

 

此时服务器状态为

 

这个时候，我们在tcpdump中可以见到：

 

在服务器ACK之前，事实上客户端经历了FIN_WAIT_1的状态，不过因为服务器很快的给予了FIN的ACK答复分节，所以这个过程转瞬即逝。

此时，客户端和服务器之间实现了所谓的半关闭。

3）  关闭服务器

客户机状态为：

 

我们tcpdump查看的数据为：

 

这表示服务器那半连接也被关闭了。

我们也可以采用JAVA客户端在WINDOWS平台上连接Fedora的C++服务器，我们在tcpdump中发现如果我们不执行close操作，则不会向服务器发送FIN分节，这也是导致了为什么在讨论JAVA客户端非正常关闭的情况下，read的结果是系统异常而不是流结束符。

 

TIME_WAIT一般会经历两个MSL，主要是为了防止化身进程和上一个关闭的进程在网络中还没有接受到的分节产生混淆。