您的位置: 首页  >  文章  >  Linux下的socket编程实践（六）设置套接字I/O超时的方案

Linux下的socket编程实践（六）设置套接字I/O超时的方案

分类: 文章 • 2024-02-28 08:44:40

Linux下的socket编程实践（六）设置套接字I/O超时的方案

（一）使用alarm 函数设置超时

[cpp] view plain copy
  1. #include <unistd.h>   
  2. unsigned int alarm(unsigned int seconds);   

它的主要功能是设置信号传送闹钟。信号SIGALRM在经过seconds指定的秒数后传送给目前的进程，如果在定时未完成的时间内再次调用了alarm函数，则后一次定时器设置将覆盖前面的设置，当seconds设置为0时，定时器将被取消。它返回上次定时器剩余时间，如果是第一次设置则返回0。

[cpp] view plain copy
  1. void sigHandlerForSigAlrm(int signo)    
  2. {    
  3.     return ;    
  4. }    
  5.     
  6. signal(SIGALRM, sigHandlerForSigAlrm);    
  7. alarm(5);    
  8. int ret = read(sockfd, buf, sizeof(buf));    
  9. if (ret == -1 && errno == EINTR)    
  10. {    
  11.     // 阻塞并且达到了5s，超时，设置返回错误码    
  12.     errno = ETIMEDOUT;    
  13. }    
  14. else if (ret >= 0)    
  15. {    
  16.     // 正常返回(没有超时), 则将闹钟关闭    
  17.     alarm(0);    
  18. }    
   如果read一直处于阻塞状态被SIGALRM信号中断而返回，则表示超时，否则未超时已读取到数据，取消闹钟。但这种方法不常用，因为有时可能在其他地方使用了alarm会造成混乱。

（二）套接字选项: SO_SNDTIMEO, SO_RCVTIMEO，调用setsockopt设置读/写超时时间

[cpp] view plain copy
  1. /示例: read超时    
  2. int seconds = 5;    
  3. if (setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &seconds, sizeof(seconds)) == -1)    
  4.     err_exit("setsockopt error");    
  5. int ret = read(sockfd, buf, sizeof(buf));    
  6. if (ret == -1 && errno == EWOULDBLOCK)    
  7. {    
  8.     // 超时,被时钟信号打断    
  9.     errno = ETIMEDOUT;    
  10. }    
   SO_RCVTIMEO是接收超时,SO_SNDTIMEO是发送超时。这种方式也不经常使用，因为这种方案不可移植，并且有些套接字的实现不支持这种方式。

（三）使用select函数实现超时

[cpp] view plain copy
  1. #include <sys/select.h>     
  2.     int select(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset,struct timeval *timeout);  
返回：做好准备的文件描述符的个数，超时为0，错误为 -1.
[cpp] view plain copy
  1. struct timeval{        
  2.         long tv_sec;   /*秒 */  
  3.         long tv_usec;  /*微秒 */     
  4.     }  

select函数是在linux编程中很重要的一个函数，他有很多的功能，控制读、写、异常的集合，当然还有设置超时。

下面我们依次封装read_timeout、write_timeout、accept_timeout、connect_timeout四个函数，来了解select在超时设置方面的使用。

1. read_timeout

[cpp] view plain copy
  1. /**  
  2.  *read_timeout - 读超时检测函数, 不包含读操作  
  3.  *@fd: 文件描述符  
  4.  *@waitSec: 等待超时秒数, 0表示不检测超时  
  5.  *成功(未超时)返回0, 失败返回-1, 超时返回-1 并且 errno = ETIMEDOUT  
  6. **/    
  7. int read_timeout(int fd, long waitSec)    
  8. {    
  9.     int returnValue = 0;    
  10.     if (waitSec > 0)    
  11.     {    
  12.         fd_set readSet;    
  13.         FD_ZERO(&readSet);    
  14.         FD_SET(fd,&readSet);    //添加    
  15.     
  16.         struct timeval waitTime;    
  17.         waitTime.tv_sec = waitSec;    
  18.         waitTime.tv_usec = 0;       //将微秒设置为0(不进行设置),如果设置了,时间会更加精确    
  19.         do    
  20.         {    
  21.             returnValue = select(fd+1,&readSet,NULL,NULL,&waitTime);    
  22.         }    
  23.         while(returnValue < 0 && errno == EINTR);   //等待被(信号)打断的情况, 重启select    
  24.     
  25.         if (returnValue == 0)   //在waitTime时间段中一个事件也没到达，超时   
  26.         {    
  27.             returnValue = -1;   //返回-1    
  28.             errno = ETIMEDOUT;    
  29.         }    
  30.         else if (returnValue == 1)  //在waitTime时间段中有事件产生    
  31.             returnValue = 0;    //返回0,表示成功    
  32.         // 如果(returnValue == -1) 并且 (errno != EINTR), 则直接返回-1(returnValue)    
  33.     }    
  34.     
  35.     return returnValue;    
  36. }   

FD_ZERO宏将一个 fd_set类型变量的所有位都设为 0，使用FD_SET将变量的某个位置位。清除某个位时可以使用 FD_CLR，我们可以使用FD_ISSET来测试某个位是否被置位。   

当声明了一个文件描述符集后，必须用FD_ZERO将所有位置零。之后将我们所感兴趣的描述符所对应的位置位，操作如下：

[cpp] view plain copy
  1.    
  2. fd_set rset;     
  3. int fd;     
  4. FD_ZERO(&rset);     
  5. FD_SET(fd, &rset);     
  6. FD_SET(stdin, &rset);  
 select返回后，用FD_ISSET测试给定位是否置位：

[cpp] view plain copy
  1. if(FD_ISSET(fd, &rset)     
  2. { ... }  


2.write_timeout

实现方式和read_timeout基本相同。

[cpp] view plain copy
  1. /**  
  2.  *write_timeout - 写超时检测函数, 不包含写操作  
  3.  *@fd: 文件描述符  
  4.  *@waitSec: 等待超时秒数, 0表示不检测超时  
  5.  *成功(未超时)返回0, 失败返回-1, 超时返回-1 并且 errno = ETIMEDOUT  
  6. **/    
  7. int write_timeout(int fd, long waitSec)    
  8. {    
  9.     int returnValue = 0;    
  10.     if (waitSec > 0)    
  11.     {    
  12.         fd_set writeSet;    
  13.         FD_ZERO(&writeSet);      //清零    
  14.         FD_SET(fd,&writeSet);    //添加    
  15.     
  16.         struct timeval waitTime;    
  17.         waitTime.tv_sec = waitSec;    
  18.         waitTime.tv_usec = 0;    
  19.         do    
  20.         {    
  21.             returnValue = select(fd+1,NULL,&writeSet,NULL,&waitTime);    
  22.         } while(returnValue < 0 && errno == EINTR); //等待被(信号)打断的情况    
  23.     
  24.         if (returnValue == 0)   //在waitTime时间段中一个事件也没到达    
  25.         {    
  26.             returnValue = -1;   //返回-1    
  27.             errno = ETIMEDOUT;    
  28.         }    
  29.         else if (returnValue == 1)  //在waitTime时间段中有事件产生    
  30.             returnValue = 0;    //返回0,表示成功    
  31.     }    
  32.     
  33.     return returnValue;    
  34. }   
3.accept_timeout

[cpp] view plain copy
  1. /**  
  2.  *accept_timeout - 带超时的accept  
  3.  *@fd: 文件描述符  
  4.  *@addr: 输出参数, 返回对方地址  
  5.  *@waitSec: 等待超时秒数, 0表示不使用超时检测, 使用正常模式的accept  
  6.  *成功(未超时)返回0, 失败返回-1, 超时返回-1 并且 errno = ETIMEDOUT  
  7. **/    
  8. int accept_timeout(int fd, struct sockaddr_in *addr, long waitSec)    
  9. {    
  10.     int returnValue = 0;    
  11.     if (waitSec > 0)    
  12.     {    
  13.         fd_set acceptSet;    
  14.         FD_ZERO(&acceptSet);    
  15.         FD_SET(fd,&acceptSet);    //添加    
  16.     
  17.         struct timeval waitTime;    
  18.         waitTime.tv_sec = waitSec;    
  19.         waitTime.tv_usec = 0;    
  20.         do    
  21.         {    
  22.             returnValue = select(fd+1,&acceptSet,NULL,NULL,&waitTime);    
  23.         }    
  24.         while(returnValue < 0 && errno == EINTR);    
  25.     
  26.         if (returnValue == 0)  //在waitTime时间段中没有事件产生    
  27.         {    
  28.             errno = ETIMEDOUT;    
  29.             return -1;    
  30.         }    
  31.         else if (returnValue == -1) // error    
  32.             return -1;    
  33.     }    
  34.     
  35.     /**select正确返回:  
  36.         表示有select所等待的事件发生:对等方完成了三次握手,  
  37.         客户端有新的链接建立,此时再调用accept就不会阻塞了  
  38.     */    
  39.     socklen_t socklen = sizeof(struct sockaddr_in);    
  40.     if (addr != NULL)    
  41.         returnValue = accept(fd,(struct sockaddr *)addr,&socklen);    
  42.     else    
  43.         returnValue = accept(fd,NULL,NULL);    
  44.     
  45.     return returnValue;    
  46. }  

4.connect_timeout

（1）我们为什么需要这个函数?

   TCP/IP在客户端连接服务器时,如果发生异常,connect(如果是在默认阻塞的情况下)返回的时间是RTT(相当于客户端阻塞了这么长的时间,客户需要等待这么长的时间,显然这样的客户端用户体验并不好(完成三次握手需要使用1.5RTT时间));会造成严重的软件质量下降.

（注：

RTT(Round-Trip Time)介绍:

   RTT往返时延:在计算机网络中它是一个重要的性能指标，表示从发送端发送数据开始，到发送端收到来自接收端的确认（接收端收到数据后便立即发送确认），总共经历的时延。

   RTT由三个部分决定：即链路的传播时间、末端系统的处理时间以及路由器的缓存中的排队和处理时间。其中，前面两个部分的值作为一个TCP连接相对固定，路由器的缓存中的排队和处理时间会随着整个网络拥塞程度的变化而变化。所以RTT的变化在一定程度上反映了网络拥塞程度的变化。简单来说就是发送方从发送数据开始，到收到来自接受方的确认信息所经历的时间。）


（2）客户端调用int connect(int sockfd, const struct sockaddr *addr, socklen_t len);发起对服务器的socket的连接请求，如果客户端socket描述符为阻塞模式则会一直阻塞到连接建立或者连接失败(注意阻塞模式的超时时间可能为75秒到几分钟之间)，而如果为非阻塞模式，则调用connect之后如果连接不能马上建立则返回-1(errno设置为EINPROGRESS，注意连接也可能马上建立成功比如连接本机的服务器进程),如果没有马上建立返回，此时TCP的三路握手动作在背后继续，而程序可以做其他的东西，然后调用select检测非阻塞connect是否完成(此时可以指定select的超时时间，这个超时时间可以设置为比connect的超时时间短)，如果select超时则关闭socket，然后可以尝试创建新的socket重新连接，如果select返回非阻塞socket描述符可写则表明连接建立成功，如果select返回非阻塞socket描述符既可读又可写则表明连接出错(注意：这儿必须跟另外一种连接正常的情况区分开来，就是连接建立好了之后，服务器端发送了数据给客户端，此时select同样会返回非阻塞socket描述符既可读又可写，这时可以通过以下方法区分:

　　1.调用getpeername获取对端的socket地址.如果getpeername返回ENOTCONN,表示连接建立失败,然后用SO_ERROR调用getsockopt得到套接口描述符上的待处理错误;

　　2.调用read,读取长度为0字节的数据.如果read调用失败,则表示连接建立失败,而且read返回的errno指明了连接失败的原因.如果连接建立成功,read应该返回0;

　　3.再调用一次connect.它应该失败,如果错误errno是EISCONN,就表示套接口已经建立,而且第一次连接是成功的;否则,连接就是失败的;

[cpp] view plain copy
  1. /* activate_nonblock - 设置IO为非阻塞模式  
  2.  * fd: 文件描述符  
  3.  */   
  4. void  activate_nonblock( int  fd)   
  5. {   
  6.      int  ret;   
  7.      int  flags = fcntl(fd, F_GETFL);   
  8.      if  (flags == - 1 )   
  9.         ERR_EXIT( "fcntl error" );   
  10.   
  11.     flags |= O_NONBLOCK;   
  12.     ret = fcntl(fd, F_SETFL, flags);   
  13.      if  (ret == - 1 )   
  14.         ERR_EXIT( "fcntl error" );   
  15. }   
  16.   
  17. /* deactivate_nonblock - 设置IO为阻塞模式  
  18.  * fd: 文件描述符  
  19.  */   
  20. void  deactivate_nonblock( int  fd)   
  21. {   
  22.      int  ret;   
  23.      int  flags = fcntl(fd, F_GETFL);   
  24.      if  (flags == - 1 )   
  25.         ERR_EXIT( "fcntl error" );   
  26.   
  27.     flags &= ~O_NONBLOCK;   
  28.     ret = fcntl(fd, F_SETFL, flags);   
  29.      if  (ret == - 1 )   
  30.         ERR_EXIT( "fcntl error" );   
  31. }   
  32.   
  33. /* connect_timeout - 带超时的connect  
  34.  * fd: 套接字  
  35.  * addr: 输出参数，返回对方地址  
  36.  * wait_seconds: 等待超时秒数，如果为0表示正常模式  
  37.  * 成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT  
  38.  */   
  39. int  connect_timeout( int  fd,  struct  sockaddr_in *addr,  unsigned   int  wait_seconds)   
  40. {   
  41.      int  ret;   
  42.     socklen_t addrlen =  sizeof ( struct  sockaddr_in);   
  43.   
  44.      if  (wait_seconds >  0 )   
  45.         activate_nonblock(fd);   
  46.   
  47.     ret = connect(fd, ( struct  sockaddr *)addr, addrlen);   
  48.      if  (ret <  0  && errno == EINPROGRESS)   
  49.     {   
  50.   
  51.         fd_set connect_fdset;   
  52.          struct  timeval timeout;   
  53.         FD_ZERO(&connect_fdset);   
  54.         FD_SET(fd, &connect_fdset);   
  55.   
  56.         timeout.tv_sec = wait_seconds;   
  57.         timeout.tv_usec =  0 ;   
  58.   
  59.          do   
  60.         {   
  61.              /* 一旦连接建立，套接字就可写 */   
  62.             ret = select(fd +  1 ,  NULL , &connect_fdset,  NULL , &timeout);   
  63.         }   
  64.          while  (ret <  0  && errno == EINTR);   
  65.   
  66.          if  (ret ==  0 )   
  67.         {   
  68.             errno = ETIMEDOUT;   
  69.              return  - 1 ;   
  70.         }   
  71.          else   if  (ret <  0 )   
  72.              return  - 1 ;   
  73.   
  74.          else   if  (ret ==  1 )   
  75.         {   
  76.              /* ret返回为1，可能有两种情况，一种是连接建立成功，一种是套接字产生错误  
  77.              * 此时错误信息不会保存至errno变量中（select没出错）,因此，需要调用  
  78.              * getsockopt来获取 */   
  79.              int  err;   
  80.             socklen_t socklen =  sizeof (err);   
  81.              int  sockoptret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &socklen);   
  82.              if  (sockoptret == - 1 )   
  83.                  return  - 1 ;   
  84.              if  (err ==  0 )   
  85.                 ret =  0 ;   
  86.              else   
  87.             {   
  88.                 errno = err;   
  89.                 ret = - 1 ;   
  90.             }   
  91.         }   
  92.     }   
  93.   
  94.      if  (wait_seconds >  0 )   
  95.         deactivate_nonblock(fd);   
  96.   
  97.      return  ret;   
  98. }  

对read_timeout的测试

[cpp] view plain copy
  1. int  ret;   
  2. ret = read_timeout(fd,  5 );   
  3. if  (ret ==  0 )   
  4.     read(fd, buf,  sizeof (buf));   
  5. else   if  (ret == - 1  && errno == ETIMEOUT)   
  6.     printf( "timeout...\n" );   
  7. else   
  8.     ERR_EXIT( "read_timeout" );  

对connect_timeout的测试

[cpp] view plain copy
  1. **测试:使用connect_timeout的client端完整代码(server端如前)**/    
  2. int main()    
  3. {    
  4.     int sockfd = socket(AF_INET, SOCK_STREAM, 0);    
  5.     if (sockfd == -1)    
  6.         err_exit("socket error");    
  7.     
  8.     struct sockaddr_in serverAddr;    
  9.     serverAddr.sin_family = AF_INET;    
  10.     serverAddr.sin_port = htons(8001);    
  11.     serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");    
  12.     int ret = connect_timeout(sockfd, &serverAddr, 5);    
  13.     if (ret == -1 && errno == ETIMEDOUT)    
  14.     {    
  15.         cerr << "timeout..." << endl;    
  16.         err_exit("connect_timeout error");    
  17.     }    
  18.     else if (ret == -1)    
  19.         err_exit("connect_timeout error");    
  20.     
  21.     //获取并打印对端信息    
  22.     struct sockaddr_in peerAddr;    
  23.     socklen_t peerLen = sizeof(peerAddr);    
  24.     if (getpeername(sockfd, (struct sockaddr *)&peerAddr, &peerLen) == -1)    
  25.         err_exit("getpeername");    
  26.     cout << "Server information: " << inet_ntoa(peerAddr.sin_addr)    
  27.                  << ", " << ntohs(peerAddr.sin_port) << endl;    
  28.     close(sockfd);    
  29. }    

参考：

http://www.cnblogs.com/zhangmo/archive/2013/04/02/2995824.html

相关推荐