Linux下connect超时处理-白红宇

Linux下connect超时处理

阅读量：6969 次

发布时间：2019-06-27

本文共 10169 字，大约阅读时间需要 33 分钟。

1、前言

　　最近在写一个测试工具，要求快速的高效率的扫描出各个服务器开放了哪些端口。当时想了一下，ping只能检测ip，判断服务器的网络是连通的，而不能判断是否开放了端口。我们知道端口属于网络的传输层，因此需要用ip和端口来探测，这个时候就可以用connect来探测一下，针对TCP协议，connect函数要进行TCP三次握手，如果connect成功，则说明服务器开放了某个端口，如果connect失败，则说明服务器没有开放某个端口。而connect失败是通过超时来控制的，在规定的时间内，connect会发起多次连接，一直执行到超时，才返回错误。默认情况下，connect是阻塞的，而且默认的超时时间为75s，正常情况下，检测网络的连通性都是毫秒级，如果要判断10万台服务器的，用阻塞的默认的connect去做，效率非常低下。因此采用非阻塞的connect，而且需要自定义超时间（我自定义超时时间为5s）。

2、非阻塞connect

　　对于阻塞式套接字，调用connect函数将激发TCP的三次握手过程，而且仅在连接建立成功或者出错时才返回；对于非阻塞式套接字，如果调用connect函数会之间返回-1（表示出错），且错误为EINPROGRESS，表示连接建立，建立启动但是尚未完成；如果返回0，则表示连接已经建立，这通常是在服务器和客户在同一台主机上时发生。

　　select是一种IO多路复用机制，它允许进程指示内核等待多个事件的任何一个发生，并且在有一个或者多个事件发生或者经历一段指定的时间后才唤醒它。connect本身并不具有设置超时功能，如果想对套接字的IO操作设置超时，可使用select函数。

　　对于select和非阻塞connect，注意两点：[1] 当连接成功建立时，描述符变成可写； [2] 当连接建立遇到错误时，描述符变为即可读，也可写，遇到这种情况，可调用getsockopt函数。

3、实现步骤

（1）创建socket，并利用fcntl将其设置为非阻塞

（2）调用connect函数，如果返回0，则连接建立；如果返回-1，检查errno ，如果值为 EINPROGRESS，则连接正在建立。

（3）为了控制连接建立时间，将该socket描述符加入到select的可读可写集合中，采用select函数设定超时。

（4）如果规定时间内成功建立，则描述符变为可写；否则，采用getsockopt函数捕获错误信息

（5）恢复套接字的文件状态并返回。

测试代码如下所示：

1 #include 
      
         2 #include 
       
          3 #include 
        
           4 #include 
         
           5 #include 
          
            /* See NOTES */ 6 #include 
           
             7 #include 
            
              8 #include 
             
               9 #include 
              
                10 11 int main(int argc, char **argv) 12 { 13 if (argc < 3) { 14 printf("please input ip and port, for example ./main 120.12.34.56 80.\n"); 15 return -1; 16 } 17 18 19 char *ipaddr = argv[1]; 20 unsigned int port = atoi(argv[2]); 21 22 int fd = 0; 23 struct sockaddr_in addr; 24 fd_set fdr, fdw; 25 struct timeval timeout; 26 int err = 0; 27 int errlen = sizeof(err); 28 29 fd = socket(AF_INET,SOCK_STREAM,0); 30 if (fd < 0) { 31 fprintf(stderr, "create socket failed,error:%s.\n", strerror(errno)); 32 return -1; 33 } 34 35 bzero(&addr, sizeof(addr)); 36 addr.sin_family = AF_INET; 37 addr.sin_port = htons(port); 38 inet_pton(AF_INET, ipaddr, &addr.sin_addr); 39 40 /*设置套接字为非阻塞*/ 41 int flags = fcntl(fd, F_GETFL, 0); 42 if (flags < 0) { 43 fprintf(stderr, "Get flags error:%s\n", strerror(errno)); 44 close(fd); 45 return -1; 46 } 47 flags |= O_NONBLOCK; 48 if (fcntl(fd, F_SETFL, flags) < 0) { 49 fprintf(stderr, "Set flags error:%s\n", strerror(errno)); 50 close(fd); 51 return -1; 52 } 53 54 /*阻塞情况下linux系统默认超时时间为75s*/ 55 int rc = connect(fd, (struct sockaddr*)&addr, sizeof(addr)); 56 if (rc != 0) { 57 if (errno == EINPROGRESS) { 58 printf("Doing connection.\n"); 59 /*正在处理连接*/ 60 FD_ZERO(&fdr); 61 FD_ZERO(&fdw); 62 FD_SET(fd, &fdr); 63 FD_SET(fd, &fdw); 64 timeout.tv_sec = 10; 65 timeout.tv_usec = 0; 66 rc = select(fd + 1, &fdr, &fdw, NULL, &timeout); 67 printf("rc is: %d\n", rc); 68 /*select调用失败*/ 69 if (rc < 0) { 70 fprintf(stderr, "connect error:%s\n", strerror(errno)); 71 close(fd); 72 return -1; 73 } 74 75 /*连接超时*/ 76 if (rc == 0) { 77 fprintf(stderr, "Connect timeout.\n"); 78 close(fd); 79 return -1; 80 } 81 /*[1] 当连接成功建立时，描述符变成可写,rc=1*/ 82 if (rc == 1 && FD_ISSET(fd, &fdw)) { 83 printf("Connect success\n"); 84 close(fd); 85 return 0; 86 } 87 /*[2] 当连接建立遇到错误时，描述符变为即可读，也可写，rc=2 遇到这种情况，可调用getsockopt函数*/ 88 if (rc == 2) { 89 if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &errlen) == -1) { 90 fprintf(stderr, "getsockopt(SO_ERROR): %s", strerror(errno)); 91 close(fd); 92 return -1; 93 94 } 95 96 if (err) { 97 errno = err; 98 fprintf(stderr, "connect error:%s\n", strerror(errno)); 99 close(fd); 100 return -1; 101 102 } 103 } 104 105 } 106 fprintf(stderr, "connect failed, error:%s.\n", strerror(errno)); 107 return -1; 108 } 109 return 0; 110 }

4、参考资料

http://dongxicheng.org/network/non-block-connect-implemention/

http://www.cnblogs.com/flyxiang2010/archive/2010/12/17/1909051.html

TCP连接的建立涉及到一个三次握手的过程，且SOCKET中connect函数需要一直等到客户接收到对于自己的SYN的ACK为止才返回，这意味着每个connect函数总会阻塞其调用进程至少一个到服务器的RTT时间，而RTT波动范围很大，从局域网的几个毫秒到几百个毫秒甚至广域网上的几秒。这段时间内，我们可以执行其他处理工作，以便做到并行。在此，需要用到非阻塞connect。本文主要介绍了非阻塞connect的编写方法以及应用场景。

1. 基础知识

(1) fcntl函数

fcntl函数可执行各种描述符的控制操作，对于socket描述符，常用应用是将其设置为阻塞式IO，代码如下：

int
flags;
if
((flags = fcntl(fd, F_GETFL)) < 0) 
//获取当前的flags标志
  
err_sys(“F_GETFL error!”);
flags |= O_NONBLOCK; 
//修改非阻塞标志位
if
(fcntl(fd, F_SETFL, flags) < 0)
  
err_sys(“F_SETFL error!”);

(2) connect函数

if
(connect(fd, (
struct
sockaddr*)&sa, 
sizeof
(sa)) == -1)
  
if
(
errno
!= EINPROGRESS) { 
   
return
-1;
  
}
  
if
(n == 0)
    
goto
done;

(3) select函数

select是一种IO多路复用机制，它允许进程指示内核等待多个事件的任何一个发生，并且在有一个或者多个事件发生或者经历一段指定的时间后才唤醒它。

connect本身并不具有设置超时功能，如果想对套接字的IO操作设置超时，可使用select函数。

fd_set wfd;
FD_ZERO(&wfd);
FD_SET(fd, &wfd);
if
(select(FD_SETSIZE, NULL, &wfd, NULL, toptr) == -1) { 
  
__redisSetError(c,REDIS_ERR_IO,
    
sdscatprintf(sdsempty(), 
"select(2): %s"
, 
strerror
(
errno
)));
  
close(fd);
  
return
REDIS_ERR;
}

对于select和非阻塞connect，注意两点：

[1] 当连接成功建立时，描述符变成可写； [2] 当连接建立遇到错误时，描述符变为即可读，也可写，遇到这种情况，可调用getsockopt函数。

(4) getsockopt函数

可获取影响套接字的选项，比如SOCKET的出错信息：

err = 0;
errlen = 
sizeof
(err);
if
(getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &errlen) == -1) { 
  
sprintf
(
"getsockopt(SO_ERROR): %s"
, 
strerror
(
errno
)));
  
close(fd);
  
return
ERR;
}
if
(err) { 
  
errno
= err;
  
close(fd);
  
return
ERR;
}

2. 实现非阻塞式connect

分以下几步：

（1）创建socket，并利用fcntl将其设置为非阻塞

（2）调用connect函数，如果返回0，则连接建立；如果返回-1，检查errno ，如果值为 EINPROGRESS，则连接正在建立。

（3）为了控制连接建立时间，将该socket描述符加入到select的可写集合中，采用select函数设定超时。

（4）如果规定时间内成功建立，则描述符变为可写；否则，采用getsockopt函数捕获错误信息

（5）恢复套接字的文件状态并返回。

3. 应用实例

（1）实例一

《unix网络编程》卷1的16.5节有一个Netscape 的web客户端的程序实例，客户端先建立一个与某个web服务器的HTTP连接，然后获取该网站的主页。该主页往往含有多个对于其他网页的引用，客户可以使用非阻塞connect同时获取多个网页，以此取代每次只获取一个网页的串行获取手段。

（2）实例二

Redis客户端CLI (command line interface)，位于源代码的src/deps/hiredis下面。实际上，不仅是Redis客户端，其他类似的client/server架构中，client均可采用非阻塞式connect实现。

int
redisContextConnectTcp(redisContext *c, 
const
char
*addr, 
int
port, 
struct
timeval *timeout) { 
 
int
s;
 
int
blocking = (c->flags & REDIS_BLOCK);
 
struct
sockaddr_in sa;
 
if
((s = redisCreateSocket(c,AF_INET)) < 0)
  
return
REDIS_ERR;
 
if
(redisSetBlocking(c,s,0) != REDIS_OK)
  
return
REDIS_ERR;
 
sa.sin_family = AF_INET;
 
sa.sin_port = htons(port);
 
if
(inet_aton(addr, &sa.sin_addr) == 0) { 
  
struct
hostent *he;
  
he = gethostbyname(addr);
  
if
(he == NULL) { 
   
__redisSetError(c,REDIS_ERR_OTHER,  sdscatprintf(sdsempty(),
"Can't resolve: %s"
,addr));
   
close(s);
   
return
REDIS_ERR;
}
memcpy
(&sa.sin_addr, he->h_addr, 
sizeof
(
struct
in_addr));
 
}
 
if
(connect(s, (
struct
sockaddr*)&sa, 
sizeof
(sa)) == -1) { 
 
if
(
errno
== EINPROGRESS && !blocking) { 
 
/* This is ok. */
 
} 
else
{ 
 
if
(redisContextWaitReady(c,s,timeout) != REDIS_OK)
 
return
REDIS_ERR;
 
}
 
}
 
/* Reset socket to be blocking after connect(2). */
 
if
(blocking && redisSetBlocking(c,s,1) != REDIS_OK)
 
return
REDIS_ERR;
 
if
(redisSetTcpNoDelay(c,s) != REDIS_OK)
 
return
REDIS_ERR;
 
c->fd = s;
 
c->flags |= REDIS_CONNECTED;
 
return
REDIS_OK;
}
static
int
redisContextWaitReady(redisContext *c, 
int
fd, 
const
struct
timeval *timeout) { 
 
struct
timeval to;
 
struct
timeval *toptr = NULL;
 
fd_set wfd;
 
int
err;
 
socklen_t errlen;
 
/* Only use timeout when not NULL. */
 
if
(timeout != NULL) { 
 
to = *timeout;
 
toptr = &to;
 
}
 
if
(
errno
== EINPROGRESS) { 
 
FD_ZERO(&wfd);
 
FD_SET(fd, &wfd);
 
if
(select(FD_SETSIZE, NULL, &wfd, NULL, toptr) == -1) { 
 
__redisSetError(c,REDIS_ERR_IO,
 
sdscatprintf(sdsempty(), 
"select(2): %s"
, 
strerror
(
errno
)));
 
close(fd);
 
return
REDIS_ERR;
 
}
 
if
(!FD_ISSET(fd, &wfd)) { 
 
errno
= ETIMEDOUT;
 
__redisSetError(c,REDIS_ERR_IO,NULL);
 
close(fd);
 
return
REDIS_ERR;
 
}
 
err = 0;
 
errlen = 
sizeof
(err);
 
if
(getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &errlen) == -1) { 
 
__redisSetError(c,REDIS_ERR_IO,
 
sdscatprintf(sdsempty(), 
"getsockopt(SO_ERROR): %s"
, 
strerror
(
errno
)));
 
close(fd);
 
return
REDIS_ERR;
 
}
 
if
(err) { 
 
errno
= err;
 
__redisSetError(c,REDIS_ERR_IO,NULL);
 
close(fd);
 
return
REDIS_ERR;
 
}
 
return
REDIS_OK;
 
}
 
__redisSetError(c,REDIS_ERR_IO,NULL);
 
close(fd);
 
return
REDIS_ERR;
}

最近在做一个在开发板启动后，程序运行前首先检查一下网络是否已经连通的东西。参考了网上的一些方法，现在整理一下。(使用system(ping IPaddress)也可以办到)

其实问题的关键是，如何设置connect函数能够在指定的时间内返回。如果直接connect一个IP地址，不成功的话将会是一个漫长的等待时间。测试了一下2分钟内没有反映，但是网上有人说是75秒,还需要进一步确认啊！

过程如下：

(1)调用fcntl，将socket置为非阻塞模式;

(2)connect();

(3)判断connect()的返回值,一般情况会返回-1,这时你还必须判断错误码如果是EINPROGRESS,那说明connect还在继续;如果错误码不是前者那么就是有问题了,不必往下执行,必须关掉socket;待下次重联;

(4)select();设置好函数中的超时时间,将select()中的read和write置位,在超时时间内,如果select返回1,即描述字变为了可写,那么连接成功。如果返回2,即描述字变为即可读又可写,那么出错。如果返回0,那么超时。

代码如下：

#include <stdio.h>

#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <errno.h>
#define TIMEOUT 5
#define SERV_PORT 53
int main(int argc, char *argv[])
{ 
                                                                   
if(argc != 2)
{ 
                                                                         
printf("Usage: client xxx.xxx.xxx.xxx\nExample: client 192.168.0.1\n");
exit(1);
}
int sockfd, flags, res;
struct sockaddr_in servaddr;
fd_set fdr, fdw;
struct timeval timeout;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if(sockfd < 0) { 
                                                                                                             
perror("Netwrok test...\n");
return -1;
}
/* set socket fd noblock */
if((flags = fcntl(sockfd, F_GETFL, 0)) < 0) { 
                                                                                                                                   
perror("Netwrok test...\n");
close(sockfd);
return -1;
}
if(fcntl(sockfd, F_SETFL, flags | O_NONBLOCK) < 0) { 
                                                                                                                                                          
perror("Network test...\n");
close(sockfd);
return -1;
}
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
inet_pton(AF_INET, argv[1], &servaddr.sin_addr);
servaddr.sin_port = htons(SERV_PORT);
if(connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) != 0) {if(errno != EINPROGRESS) { // EINPROGRESS 
perror("Network test...\n");
close(sockfd);
return -1;
}
}
else { 
                         
printf("Connected\n");
return 0;
}
FD_ZERO(&fdr);
FD_ZERO(&fdw);
FD_SET(sockfd, &fdr);
FD_SET(sockfd, &fdw);
timeout.tv_sec = TIMEOUT;
timeout.tv_usec = 0;
res = select(sockfd + 1, &fdr, &fdw, NULL, &timeout);
if(res < 0) { 
                                                                            
perror("Network test...\n");
close(sockfd);
return -1;
}
if(res == 0) { 
                                                                                               
printf("Connect server timeout")
close(sockfd);
return -1;
}
if(res == 1) { 
                                                                                                                 
if(FD_ISSET(sockfd, &fdw))
{ 
                                                                                                                         
printf("Connected\n");
close(sockfd);
return 0;
}
}
/* Not necessary */
if(res == 2) { 
                                                                                                                                             
printf("Connect server timeout");
close(sockfd);
return -1;
}
printf("Connect server timeout");
close(sockfd);
return -1;
}