socket断开连接



socket断开连接

/

 自动检测SOCKET链接断开
1.c/s结构中，client与server建立连接，服务端使用专门的线程处理一条socket连接。
 server处于绝对被动的，不能主动断开连接。
 也没有连接链路维持包之类的。
 client发送的时间是不一定的。
 socket连接断开后，server要感知并释放资源。

这个问题在思考测试，询问同事之后，找到了一个方法，可以做到这一点。
当使用 select()函数测试一个socket是否可读时，如果select()函数返回值为1，且使用recv()函数读取的数据长度为0 时，就说明该socket已经断开。
为了更好的判定socket是否断开，我判断当recv()返回值小于等于0时，socket连接断开。但是还需要判断 errno是否等于 EINTR 。如果errno == EINTR 则说明recv函数是由于程序接收到信号后返回的，socket连接还是正常的，不应close掉socket连接。

PS：对于堵塞socket的recv函数会在以下三种情况下返回：
（1）recv到数据时，会返回。
（2）在整个程序接收到信号时，返回-1。errno = EINTR。//在程序的起始阶段，屏蔽掉信号的除外。部分信号还是屏蔽不掉的。
（3）socket出现问题时，返回-1.具体错误码看 man recv()
（4）一定要看 man 说明，很详细，很有帮助。
这种方法经过长时间测试后，是有效的。所以写出来让大家参考一下，请大家发表意见。

我的方法不一样，我用getsockopt来判断，还是蛮准确的 

1. int SocketConnected(int sock)
   
2. {
   
3. if(sock<=0)
   
4. return 0;
   
5. struct tcp_info info;
   
6. int len=sizeof(info);
   
7. getsockopt(sock, IPPROTO_TCP, TCP_INFO, &info, (socklen_t *)&len);
   
8. if((info.tcpi_state==TCP_ESTABLISHED))
   
9. {
   
10. //myprintf("socket connected\n");
    
11. return 1;
    
12. }
    
13. else
    
14. {
    
15. //myprintf("socket disconnected\n");
    
16. return 0;
    
17. }
    
18. }

tcp_info和 TCP_ESTABLISHED 在 linux/tcp.h

包含

#include <linux/types.h>
#include <asm/byteorder.h>
#include <linux/config.h>
#include < linux/skbuff.h>
#include < linux/ip.h>
#include < net/sock.h>

http://www.cse.scu.edu/~dclark/am_256_graph_theory/linux_2_6_stack/globals.html#index_t

int SocketConnected(int sock) 
{ 
if(sock<=0) 
return 0; 
struct tcp_info info; 
int len=sizeof(info); 
getsockopt(sock, IPPROTO_TCP, TCP_INFO, &info, (socklen_t *)&len); 
if((info.tcpi_state==TCP_ESTABLISHED)) 
{ 
//myprintf("socket connected\n"); 
return 1; 
} 
else 
{ 
//myprintf("socket disconnected\n"); 
return 0; 
} 
}

目前主要有三种方法来实现用户掉线检测：SO_KEEPALIVE ,SIO_KEEPALIVE_VALS 和Heart-Beat线程。

下面我就上面的三种方法来做一下介绍。

(1)SO_KEEPALIVE 机制

        这是socket库提供的功能，设置接口是setsockopt API：

   BOOL bSet=TRUE;

   setsockopt(hSocket,SOL_SOCKET,SO_KEEPALIVE,(const char*)&bSet,sizeof(BOOL));

       根据MSDN的文档，如果为socket设置了KEEPALIVE选项，TCP/IP栈在检测到对方掉线后，

   任何在该socket上进行的调用(发送/接受调用)就会立刻返回，错误号是WSAENETRESET ；

   同时，此后的任何在该socket句柄的调用会立刻失败，并返回WSAENOTCONN错误。

 

   该机制的缺点也很明显：

         默认设置是空闲2小时才发送一个“保持存活探测分节”，不能保证实时检测！

   当然也可以修改时间间隔参数，但是会影响到所有打开此选项的套接口！

         关联了完成端口的socket可能会忽略掉该套接字选项。

 

 

(2)SIO_KEEPALIVE_VALS 机制

         设置接口是WSAIoctl API:

     DWORD dwError = 0L ;

     tcp_keepalive sKA_Settings = {0}, sReturned = {0} ;

     sKA_Settings.onoff = 1 ;

     sKA_Settings.keepalivetime = 5500 ; // Keep Alive in 5.5 sec.

     sKA_Settings.keepaliveinterval = 3000 ; // Resend if No-Reply

     if (WSAIoctl(skNewConnection, SIO_KEEPALIVE_VALS, &sKA_Settings,

          sizeof(sKA_Settings), &sReturned, sizeof(sReturned), &dwBytes,

          NULL, NULL) != 0)

     {

           dwError = WSAGetLastError() ;

     }

     实现时需要添加tcp_keepalive and SIO_KEEPALIVE_VALS的定义文件MSTCPiP.h

     该选项不同于SO_KEEPALIVE 机制的就是它是针对单个连接的，对系统其他的套接

     口并不影响。

        针对完成端口的socket,设置了SIO_KEEPALIVE_VALS后，激活包由TCP STACK来负责。

     当网络连接断开后，TCP STACK并不主动告诉上层的应用程序，但是当下一次RECV或者SEND操作

     进行后，马上就会返回错误告诉上层这个连接已经断开了.如果检测到断开的时候，在这个连接

     上有正在PENDING的IO操作，则马上会失败返回.

 

 

     该机制的缺点：

             不通用啦。MS的API只能用于Windows拉。不过，优雅一些^_^.

    

(3)Heart-Beat线程

        没说的。自己写一个后台线程，实现Heart-Beat包，客户端受到该包后，立刻返回相应的反馈 包。

 

    该方法的好处是通用，但缺点就是会改变现有的通讯协议！

1. /* Net check Make sure you have not used OUT OF BAND DATA AND YOU CAN use OOB */
   
2. int netcheck(int fd) 
   
3. {
   
4.         int buf_size = 1024;
   
5.         char buf[buf_size];
   
6.         //clear OOB DATA 
   
7.         recv(fd, buf, buf_size);
   
8.         if(send(fd, (void *)"\0", 1, MSG_OOB) < 0 )
   
9.         {
   
10.                 fprintf(stderr, "Connection[%d] send OOB failed, %s", fd, strerror(errno));
    
11.                 return -1;
    
12.         }
    
13.         return 0;
    
14. }

复制代码

1. /* Setting SO_TCP KEEPALIVE */
   
2. //int keep_alive = 1;//设定KeepAlive
   
3. //int keep_idle = 1;//开始首次KeepAlive探测前的TCP空闭时间
   
4. //int keep_interval = 1;//两次KeepAlive探测间的时间间隔
   
5. //int keep_count = 3;//判定断开前的KeepAlive探测次数
   
6. void set_keepalive(int fd, int keep_alive, int keep_idle, int keep_interval, int keep_count)
   
7. {
   
8.         int opt = 1;
   
9.         if(keep_alive)
   
10.         {
    
11.                 if(setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE,
    
12.                                         (void*)&keep_alive, sizeof(keep_alive)) == -1)
    
13.                 {
    
14.                         fprintf(stderr, 
    
15.                                 "setsockopt SOL_SOCKET::SO_KEEPALIVE failed, %s\n",strerror(errno));
    
16.                 }
    
17.                 if(setsockopt(fd, SOL_TCP, TCP_KEEPIDLE,
    
18.                                         (void *)&keep_idle,sizeof(keep_idle)) == -1)
    
19.                 {
    
20.                         fprintf(stderr,
    
21.                                 "setsockopt SOL_TCP::TCP_KEEPIDLE failed, %s\n", strerror(errno));
    
22.                 }
    
23.                 if(setsockopt(fd,SOL_TCP,TCP_KEEPINTVL,
    
24.                                         (void *)&keep_interval, sizeof(keep_interval)) == -1)
    
25.                 {
    
26.                         fprintf(stderr,
    
27.                                  "setsockopt SOL_tcp::TCP_KEEPINTVL failed, %s\n", strerror(errno));
    
28.                 }
    
29.                 if(setsockopt(fd,SOL_TCP,TCP_KEEPCNT,
    
30.                                         (void *)&keep_count,sizeof(keep_count)) == -1)
    
31.                 {
    
32.                         fprintf(stderr, 
    
33.                                 "setsockopt SOL_TCP::TCP_KEEPCNT failed, %s\n", strerror(errno));
    
34.                 }
    
35.         }
    
36. }