求用过TCP KEEPALIVE的大侠指点一下

frank529

最近在做一个项目需要监测TCP连接非正常断开，不想添加额外消息所以不用心跳机制。网上查了关于TCP KEEPALIVE的设置，按我的理解如果TCP KEEPALIVE在发现tcp socket断连后，应该对它做一些处理，使得对它的操作select、read、write等产生错误（Windows就是这么干的）。但实际情况是，网络断连后，如果这个socket只做read操作，那么select不会阻塞，正常返回0，read返回值为0。但如果这个socket同时在做write操作，则select一直阻塞，这样在发送缓冲区溢出前我一直知道网络断连。网上的资料都是关于怎么开启keepalive，设置keepalive的时间、间隔和重复次数，并没有关于keepalive在发现断连后是怎样通知上层的，希望高手指点。

为了方便阅读，贴个测试代码的大致结构，详细测试代码见跟帖，大家可以试试，看情况是不是和我描述的一样，还是我的代码有问题。

1. int main(void)
   
2. {
   
3.         int server_sockfd, client_sockfd;
   
4.         fd_set        reader_fds;
   
5.         int ret;
   
6. 
   
7.         /* 创建server_sockfd绑定侦听 */
   
8.         ...
   
9. 
   
10. 
    
11.         FD_ZERO(&reader_fds);
    
12.         FD_SET(server_sockfd, &reader_fds);       
    
13. 
    
14. 
    
15.         while(1)
    
16.         {
    
17.                 ret = select(READER_FDSIZE, &reader_fds,(fd_set *)0, (fd_set *)0 , NULL);
    
18.                 if(res < 0)
    
19.                         perror("select");
    
20. 
    
21.                 /* 有客户端连入 */
    
22.                 if(FD_ISSET(server_sockfd, &reader_fds))
    
23.                 {
    
24.                         client_sockfd = accept...
    
25. 
    
26.                         /* 配置client_sockfd非阻塞，开启TCP KEEPALIVE，设置KEEPALIVE时间、间隔和重发次数 */
    
27.                         ...
    
28. 
    
29.                         /* 创建发送线程，每隔几秒向client_sockfd write消息 */
    
30.                         ...
    
31. 
    
32.                         /* client_sockfd加入reader_fds */
    
33.                         FD_SET(client_sockfd, &reader_fds);
    
34.                         continue;
    
35.                 }
    
36. 
    
37.                 if(FD_ISSET(client_sockfd, &reader_fds))
    
38.                 {
    
39.                         ioctl(client_sockfd, FIONREAD, &nread);        // 判断缓冲区有多少数据可读
    
40.                         /* 如果没有发送线程，网络断连后，select会不断返回，nread一直为0；*/
    
41.                         /* 有发送线程，断连后select会阻塞，不会运行到此处 */
    
42.                         /* nread不为0读取数据 */
    
43.                 }
    
44.         }
    
45. }
    

复制代码

PS：虽然这个问题属于应用层范畴，但TCP KEEPALIVE与内核网络协议栈有关，CU内核版人气旺一些，所以发到这里，望版主手下留情。

frank529

测试代码，服务器端，环境Linux2.6.30

1. #include <string.h>
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <sys/ioctl.h>
   
5. #include <netdb.h>
   
6. #include <net/if.h>
   
7. #include <netinet/in.h>
   
8. #include <net/if_arp.h>
   
9. #include <sys/socket.h>
   
10. #include <arpa/inet.h>
    
11. #include <ifaddrs.h>
    
12. #include <errno.h>
    
13. #include <fcntl.h>
    
14. #include <unistd.h>
    
15. #include <termios.h>
    
16. #include <pthread.h>
    
17. #include <netinet/tcp.h>
    
18. 
    
19. #define READER_FDSIZE 10
    
20. 
    
21. int client_sockfd;
    
22. 
    
23. void *sendmsg_thread(void *arg)
    
24. {
    
25.         int netcnt;
    
26.         while(1)
    
27.         {
    
28.                 netcnt = send(client_sockfd,"hello client",strlen("hello client")+1,0);
    
29.                 if(netcnt != strlen("hello client")+1)
    
30.                         printf("netcnd = %d\n",netcnt);
    
31.                 sleep(2);
    
32.         }
    
33. }
    
34. 
    
35. int main(void)
    
36. {
    
37.         int server_sockfd;
    
38.         struct sockaddr_in server_sockaddr,client_sockaddr;
    
39.         fd_set        reader_fds, error_fds;
    
40.         int res = 0;
    
41.         int sin_size;
    
42.         int nread;
    
43.         char *rcvbuffer;
    
44.         pthread_t thread_send_msg;
    
45.         int optval;
    
46.         socklen_t optlen = sizeof(optval);
    
47. 
    
48. 
    
49. 
    
50.         /*创建socket连接*/
    
51.         if((server_sockfd = socket(AF_INET,SOCK_STREAM,0))== -1)
    
52.         {
    
53.                 perror("socket");
    
54.                 server_sockfd = -1;
    
55.                 goto exit;
    
56.         }               
    
57. 
    
58.         /*enable address reuse */
    
59.         int on;
    
60.         int ret;
    
61.         on = 1;
    
62.         ret = setsockopt(server_sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
    
63.        
    
64.         /*设置sockaddr_in 结构体中相关参数*/
    
65.         server_sockaddr.sin_family = AF_INET;
    
66.         server_sockaddr.sin_port = htons(7086);
    
67.         server_sockaddr.sin_addr.s_addr = INADDR_ANY;
    
68.         bzero(&(server_sockaddr.sin_zero),8);
    
69. 
    
70.         /*绑定函数bind*/
    
71.         if(bind(server_sockfd,(struct sockaddr *)&server_sockaddr,sizeof(struct sockaddr))== -1)
    
72.         {
    
73.                 perror("bind");
    
74.                 server_sockfd = -1;       
    
75.                 goto exit;               
    
76.         }
    
77. 
    
78.         /*调用listen函数*/
    
79.         if(listen(server_sockfd,10)== -1)
    
80.         {
    
81.                 perror("listen");       
    
82.                 server_sockfd = -1;       
    
83.                 goto exit;               
    
84.         }
    
85. 
    
86.         FD_ZERO(&reader_fds);
    
87.         FD_SET(server_sockfd, &reader_fds);       
    
88. 
    
89.         while(1)
    
90.         {
    
91.                 res = select(READER_FDSIZE, &reader_fds,(fd_set *)0, (fd_set *)0 , NULL);
    
92.                 if(res < 0)
    
93.                         perror("select");
    
94. 
    
95.                 /* 有客户端连入 */
    
96.                 if(FD_ISSET(server_sockfd, &reader_fds))
    
97.                 {       
    
98.                         sin_size = sizeof(struct sockaddr);
    
99.                         client_sockfd = accept(server_sockfd,(struct sockaddr *)&client_sockaddr,&sin_size);
    
100.                         if(client_sockfd < 0)
     
101.                         {                               
     
102.                                 perror("accept");
     
103.                                 goto exit;               
     
104.                         }
     
105. 
     
106.                         /* 开启KEEPALIVE */
     
107.                         optval = 1;
     
108.                         optlen = sizeof(optval);
     
109.                         if(setsockopt(client_sockfd, SOL_SOCKET, SO_KEEPALIVE, &optval, optlen) < 0)
     
110.                         {
     
111.                                 perror("setsockopt()");
     
112.                                 close(client_sockfd);
     
113.                                 goto exit;               
     
114.                         }
     
115.                         printf("SO_KEEPALIVE set on socket\n");
     
116. 
     
117.                         /* 设置KEEPALIVE时间为1s */
     
118.                         optval = 1;
     
119.                         res = setsockopt(client_sockfd, SOL_TCP, TCP_KEEPIDLE, &optval, optlen);
     
120.                         if(res < 0)
     
121.                                 perror("setsockopt TCP_KEEPIDLE");
     
122. 
     
123.                         /* 设置KEEPALIVE间隔为1s */
     
124.                         res = setsockopt(client_sockfd, SOL_TCP, TCP_KEEPINTVL, &optval, optlen);
     
125.                         if(res < 0)
     
126.                                 perror("setsockopt TCP_KEEPIDLE");
     
127. 
     
128.                         /* 设置KEEPALIVE重试次数为3次 */
     
129.                         optval = 3;
     
130.                         res = setsockopt(client_sockfd, SOL_TCP, TCP_KEEPCNT, &optval, optlen);
     
131.                         if(res < 0)
     
132.                                 perror("setsockopt TCP_KEEPIDLE");
     
133. 
     
134.                         fcntl(client_sockfd,F_SETFL,O_NONBLOCK);        // 设置非阻塞
     
135.                         FD_SET(client_sockfd, &reader_fds);        // client_sockfd加入reader_fds
     
136. 
     
137.                         /* 创建发送线程 */
     
138.                         ret = pthread_create(&thread_send_msg, NULL, sendmsg_thread, NULL);
     
139.                         continue;
     
140.                 }
     
141. 
     
142. 
     
143.                 if(FD_ISSET(client_sockfd, &reader_fds))
     
144.                 {
     
145.                         /* 如果没有发送线程，网络断连后，select会不断返回，nread一直为0；*/
     
146.                         /* 有发送线程，断连后select会阻塞，不会运行到此处 */
     
147.                         ioctl(client_sockfd, FIONREAD, &nread);
     
148.                         if(nread <= 0)
     
149.                         {
     
150.                                 printf("nread = %d\n",nread);
     
151.                         }
     
152.                         else
     
153.                         {
     
154.                                 rcvbuffer = malloc(nread);
     
155.                                 res = read(client_sockfd, rcvbuffer, nread);         
     
156.                                 if(nread > 0)
     
157.                                 {
     
158.                                         printf("receive %s\n",rcvbuffer);
     
159.                                 }
     
160.                                 free(rcvbuffer);
     
161.                         }
     
162.                 }
     
163.                
     
164.         }
     
165. exit:
     
166.         return -1;
     
167. }
     

复制代码

frank529

客户端代码，编译环境VC6.0，运行环境Window XP

1. #include "stdafx.h"
   
2. 
   
3. #include <Winsock2.h>
   
4. #pragma comment(lib, "ws2_32.lib")
   
5. 
   
6. int main()
   
7. {
   
8.         WORD wVersionRequested;    WSADATA wsaData;   
   
9.         int err;        
   
10.         wVersionRequested = MAKEWORD( 1, 1 );        
    
11.         err = WSAStartup( wVersionRequested, &wsaData );
    
12.         char recvBuf[1024] = {'\0'};
    
13.         if ( err != 0 )
    
14.                 return -1;
    
15. 
    
16.         SOCKET sockClient=socket(AF_INET,SOCK_STREAM,0);
    
17.         SOCKADDR_IN addrSrv;
    
18.         addrSrv.sin_addr.S_un.S_addr=inet_addr("192.168.1.213");    // 设置服务器IP
    
19.         addrSrv.sin_family=AF_INET;
    
20.         addrSrv.sin_port=htons(7086);
    
21.        
    
22.         err = connect(sockClient,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));
    
23.         if(err < 0)
    
24.         {
    
25.                 printf("connect error\n");
    
26.                 return -1;
    
27.         }
    
28. 
    
29.         while(1)
    
30.         {
    
31.                 #if 服务器开启了发送线程
    
32.                 if(recv(sockClient,recvBuf,1024,0) > 0)
    
33.                 {
    
34.                         printf("%s\n",recvBuf);
    
35.                         memset(recvBuf,0,1024);
    
36. 
    
37.                         err = send(sockClient,"hello server",strlen("hello server")+1,0);
    
38.                         if(err != strlen("hello server")+1)
    
39.                         {
    
40.                                 printf("send error\n");
    
41.                                 return -1;       
    
42.                         }
    
43.                 }
    
44.                 #else 服务器只接收
    
45.                 err = send(sockClient,"hello server",strlen("hello server")+1,0);
    
46.                 if(err != strlen("hello server")+1)
    
47.                 {
    
48.                         printf("send error\n");
    
49.                         return -1;       
    
50.                 }
    
51. 
    
52.                 Sleep(2000);
    
53.                 #endif
    
54.         }
    
55. 
    
56.         return 0;
    
57. }

复制代码

frank529

擦，http://www.cnblogs.com/liuweijian/archive/2009/12/27/1633142.html这篇文章里说：

如果心搏函数要维护客户端的存活，即服务器必须每隔一段时间必须向客户段发送一定的数据，那么使用SO_KEEPALIVE是有很大的不足的。因为SO_KEEPALIVE选项指"此套接口的任一方向都没有数据交换",我不知道大家是怎么理解这个实现的。在Linux 2.6系列上，上面话的理解是只要打开SO_KEEPALIVE选项的套接口端检测到数据发送或者数据接受就认为是数据交换。

因此在这种情况下使用 SO_KEEPALIVE选项 检测对方是否非正常连接是完全没有作用的，在每隔一段时间发包的情况， keep-alive的包是不可能被发送的。上层程序在非正常端开的情况下是可以正常发送包到缓冲区的。非正常端开的情况是指服务器没有收到"FIN" 或者 "RST"包。

也就是说，只要你在发数据，keepalive包就不会发送。