UNIX网络编程--非阻塞connect的实现

一、《UNIX网络编程》-非阻塞connect

         在一个TCP套接口被设置为非阻塞之后调用connect,connect会立即返回EINPROGRESS错误,表示连接操作正在进行中,但是仍未完成;同时TCP的三路握手操作继续进行;在这之后,我们可以调用select来检查这个链接是否建立成功;

非阻塞connect有三种用途:
    1.我们可以在三路握手的同时做一些其它的处理.connect操作要花一个往返时间完成,而且可以是在任何地方,从几个毫秒的局域网到几百毫秒或几秒的广域网.在这段时间内我们可能有一些其他的处理想要执行;
    2.可以用这种技术同时建立多个连接.在Web浏览器中很普遍;
    3.由于我们使用select来等待连接的完成,因此我们可以给select设置一个时间限制,从而缩短connect的超时时间.在大多数实现中,connect的超时时间在75秒到几分钟之间.有时候应用程序想要一个更短的超时时间,使用非阻塞connect就是一种方法;
非阻塞connect听起来虽然简单,但是仍然有一些细节问题要处理:
   1.即使套接口是非阻塞的,如果连接的服务器在同一台主机上,那么在调用connect建立连接时,连接通常会立即建立成功.我们必须处理这种情况;
   2.源自Berkeley的实现(和Posix.1g)有两条与select和非阻塞IO相关的规则:
       A:当连接建立成功时,套接口描述符变成可写;
       B:当连接出错时,套接口描述符变成既可读又可写;
  注意:当一个套接口出错时,它会被select调用标记为既可读又可写;

当发现套接口描述符可读或可写时，可进一步判断是连接成功还是出错。这里必须将B）和另外一种连接正常的情况区分开，就是连接建立好了之后，服务器端发送了数据给客户端，此时select同样会返回非阻塞socket描述符既可读又可写。

    因此，仅从socket可读或可写无法判断socket连接的状态。

非阻塞connect有这么多好处,但是处理非阻塞connect时会遇到很多可移植性问题;

        在处理非阻塞connect时,在不同的套接口实现的平台中存在的移植性问题,首先,有可能在调用select之前,连接就已经建立成功,而且对方的数据已经到来.在这种情况下,连接成功时套接口将既可读又可写.这和连接失败时是一样的.这个时候我们还得通过getsockopt来读取错误值;这是第二个可移植性问题;

移植性问题总结:
     1.对于出错的套接口描述符,getsockopt的返回值源自Berkeley的实现是返回0,待处理的错误值存储在errno中;而源自Solaris的实现是返回0,待处理的错误存储在errno中;(套接口描述符出错时调用getsockopt的返回值不可移植)
     2.有可能在调用select之前,连接就已经建立成功,而且对方的数据已经到来,在这种情况下,套接口描述符是既可读又可写;这与套接口描述符出错时是一样的;(怎样判断连接是否建立成功的条件不可移植)

这样的话,在我们判断连接是否建立成功的条件不唯一时,我们可以有以下的方法来解决这个问题:
     1.调用getpeername代替getsockopt.如果调用getpeername失败,getpeername返回ENOTCONN,表示连接建立失败,我们必须以SO_ERROR调用getsockopt得到套接口描述符上的待处理错误; 此为《Unix Network Programming》一书中提供的方法，该方法在Linux环境上测试，发现是无效的
     2.调用read,读取长度为0字节的数据.如果read调用失败,则表示连接建立失败,而且read返回的errno指明了连接失败的原因.如果连接建立成功,read应该返回0;
     3.再调用一次connect.它应该失败,如果错误errno是EISCONN,就表示套接口已经建立,而且第一次连接是成功的;否则,连接就是失败的;

被中断的connect(这是说明使用非阻塞connect的必要性):
如果在一个阻塞式套接口上调用connect,在TCP的三路握手操作完成之前被中断了,比如说,被捕获的信号中断,将会发生什么呢?假定connect不会自动重启,它将返回EINTR.那么,这个时候,我们就不能再调用connect等待连接建立完成了,如果再次调用connect来等待连接建立完成的话,connect将会返回错误值EADDRINUSE.在这种情况下,应该做的是调用select,就像在非阻塞式connect中所做的一样.然后,select在连接建立成功(使套接口描述符可写)或连接建立失败(使套接口描述符既可读又可写)时返回。

上述是书中的内容。

二、非阻塞connect的实现

        在一个TCP套接口设置为非阻塞后，调用connect，connect会在系统提供的errno变量中返回一个EINRPOCESS错误，此时TCP的三路握手继续进行。之后可以用select函数检查这个连接是否建立成功。以下实验基于unix网络编程和网络上给出的普遍示例，在经过大量测试之后，发现其中有很多方法，在linux中，并不适用。
我先给出了重要源码的逐步分析，在最后给出完整的connect非阻塞源码。
        1.首先填写套接字结构，包括远程的ip，通信端口如下： */

[cpp]  view plain  copy

 

1. struct sockaddr_in serv_addr;  
2. serv_addr.sin_family=AF_INET;  
3. serv_addr.sin_port=htons(9999);  
4. serv_addr.sin_addr.s_addr = inet_addr("58.31.231.255"); //inet_addr转换为网络字节序  
5. bzero(&(serv_addr.sin_zero),8);  

// 2.建立socket套接字：
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
perror("socket creat error");
return 1;
}

// 3.将socket建立为非阻塞，此时socket被设置为非阻塞模式
flags = fcntl(sockfd,F_GETFL,0);//获取建立的sockfd的当前状态（非阻塞）
fcntl(sockfd,F_SETFL,flags|O_NONBLOCK);//将当前sockfd设置为非阻塞

4. 建立connect连接，此时socket设置为非阻塞，connect调用后，无论连接是否建立立即返回-1，同时将errno（包含errno.h就可以直接使用）设置为EINPROGRESS, 表示此时tcp三次握手仍旧进行，如果errno不是EINPROGRESS，则说明连接错误，程序结束。
当客户端和服务器端在同一台主机上的时候，connect回马上结束，并返回0；无需等待，所以使用goto函数跳过select等待函数，直接进入连接后的处理部分。

[cpp]  view plain  copy

 

1. if ( ( n = connect( sockfd, ( struct sockaddr *)&serv_addr , sizeof(struct sockaddr)) ) < 0 )  
2. {  
3. if(errno != EINPROGRESS)    return 1;  
4. }  
5. if(n==0)  
6. {  
7. printf("connect completed immediately");  
8. goto done;  
9. }  

/5.设置等待时间，使用select函数等待正在后台连接的connect函数，这里需要说明的是使用select监听socket描述符是否可读或者可写，如果只可写，说明连接成功，可以进行下面的操作。如果描述符既可读又可写，分为两种情况，第一种情况是socket连接出现错误（不要问为什么，这是系统规定的，可读可写时候有可能是connect连接成功后远程主机断开了连接close(socket)），第二种情况是connect连接成功，socket读缓冲区得到了远程主机发送的数据。需要通过connect连接后返回给errno的值来进行判定，或者通过调用 getsockopt(sockfd,SOL_SOCKET,SO_ERROR,&error,&len); 函数返回值来判断是否发生错误，这里存在一个可移植性问题，在solaris中发生错误返回-1，但在其他系统中可能返回0.我首先按unix网络编程的源码进行实现。如下：
FD_ZERO(&rset);
FD_SET(sockfd,&rset);
wset = rset;
tval.tv_sec = 0;
tval.tv_usec = 300000;
int error;
socklen_t len;
if(( n = select(sockfd+1, &rset, &wset, NULL,&tval)) <= 0)
{
printf("time out connect error");
close(sockfd);
return -1;
}
If ( FD_ISSET(sockfd,&rset) || FD_ISSET(sockfd,&west) )
{
len = sizeof(error);
if( getsockopt(sockfd,SOL_SOCKET,SO_ERROR,&error,&len) <0)
return 1;
}

对错误的处理：

这里我测试了一下，按照unix网络编程的描述，当网络发生错误的时候，getsockopt返回-1，return -1，程序结束。网络正常时候返回0，程序继续执行。
       可是我在linux下，无论网络是否发生错误，getsockopt始终返回0，不返回-1，说明linux与unix网络编程还是有些细微的差别。就是说当socket描述符可读可写的时候，这段代码不起作用。不能检测出网络是否出现故障。
      我测试的方法是，当调用connect后，sleep（2）休眠2秒，借助这两秒时间将网络助手断开连接，这时候select返回2，说明套接口可读又可写，应该是网络连接的出错情况。
      此时，getsockopt返回0，不起作用。获取errno的值，指示为EINPROGRESS，没有返回unix网络编程中说的ENOTCONN，EINPROGRESS表示正在试图连接，不能表示网络已经连接失败。
      针对这种情况，unix网络编程中提出了另外3种方法，这3种方法，也是网络上给出的常用的非阻塞connect示例：
    a.再调用connect一次。失败返回errno是EISCONN说明连接成功，表示刚才的connect成功，否则返回失败。 代码如下：

[cpp]  view plain  copy

 

1. int connect_ok;  
2. connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(struct sockaddr) );  
3. switch (errno)  
4. {  
5. case EISCONN:   //connect ok  
6. printf("connect OK \n");  
7. connect_ok = 1;  
8. break;  
9. case EALREADY:  
10. connect_0k = -1  
11. break;  
12. case EINPROGRESS: // is connecting, need to check again  
13. connect_ok = -1  
14. break;  
15. default:  
16. printf("connect fail err=%d \n",errno);  
17. connect_ok = -1;  
18. break;  
19. }  

如程序所示，根据再次调用的errno返回值将connect_ok的值，来进行下面的处理，connect_ok为1继续执行其他操作，否则程序结束。

         但这种方法我在linux下测试了，当发生错误的时候,socket描述符（我的程序里是sockfd）变成可读且可写，但第二次调用connect 后，errno并没有返回EISCONN，,也没有返回连接失败的错误，仍旧是EINPROGRESS，而当网络不发生故障的时候，第二次使用 connect连接也返回EINPROGRESS，因此也无法通过再次connect来判断连接是否成功。

    在这种情况下的测试还有一个问题需要提出：

     一次select之后，发现此时套接口描述字可读或可写，再次执行connect，此时errno始终不变，仍未EINPROGRESS，增加select的超时时间结果也一样。

    之后尝试在select返回值为0，或返回值为1，且connect后errno仍为EINPROGRESS(115)时，再次执行select+connect，即再次检测连接状态。此时errno被置为EISCONN(106)，connect成功。（也就是说使用这种判断可以解决移植问题）

     b.unix网络编程中说使用read函数，如果失败，表示connect失败，返回的errno指明了失败原因，但这种方法在linux上行不通，linux在socket描述符为可读可写的时候，read返回0，并不会置errno为错误。
       c.unix网络编程中说使用getpeername函数，如果连接失败，调用该函数后，通过errno来判断第一次连接是否成功，但我试过了，无论网络连接是否成功，errno都没变化，都为EINPROGRESS，无法判断。
        即使调用getpeername函数，getsockopt函数仍旧不行。
       综上方法，既然都不能确切知道非阻塞connect是否成功，所以我直接当描述符可读可写的情况下进行发送，通过能否获取服务器的返回值来判断是否成功。(如果服务器端的设计不发送数据，那就悲哀了。)
       程序的书写形式出于可移植性考虑，按照unix网络编程推荐写法，使用getsocketopt进行判断，但不通过返回值来判断，而通过函数的返回参数来判断。

6. 用select查看接收描述符，如果可读，就读出数据，程序结束。在接收数据的时候注意要先对先前的rset重新赋值为描述符，因为select会对 rset清零，当调用select后，如果socket没有变为可读，则rset在select会被置零。所以如果在程序中使用了rset，最好在使用时候重新对rset赋值。
程序如下：
FD_ZERO(&rset);
FD_SET(sockfd,&rset);//如果前面select使用了rset，最好重新赋值
if( ( n = select(sockfd+1,&rset,NULL, NULL,&tval)) <= 0 )
{
close(sockfd);
return -1;
} 
if ((recvbytes=recv(sockfd, buf, 1024, 0)) ==-1)
{
perror("recv error!");
close(sockfd);
return 1;
}
printf("receive num %d\n",recvbytes);
printf("%s\n",buf);
*/ 

       综上所述一种更有效的判断方法，经测试验证，在Linux环境下是有效的：

       再次调用connect，相应返回失败，如果错误errno是EISCONN，表示socket连接已经建立，否则认为连接失败。

三、非阻塞connect的实现

[cpp]  view plain  copy

 

1.  #include <stdio.h>      
2.  #include <string.h>      
3.  #include <stdlib.h>  
4.  #include <sys/types.h>      
5.  #include <errno.h>  
6.  #include <unistd.h>      
7.  #include <fcntl.h>      
8.  #include <sys/select.h>      
9.  #include<sys/ioctl.h>//inet_addr()      
10.  #include <sys/socket.h>      
11.  #include <netinet/in.h>      
12.  #include <arpa/inet.h>  
13.  #define PEER_IP     "192.254.1.1"      
14.  #define PEER_PORT   7008  
15. int main(int argc, char **argv)      
16.  {      
17.   int ret = 0;      
18.   int sock_fd;      
19.   int flags;      
20.   struct sockaddr_in addr;      
21.         
22.   /* obtain a socket */      
23.   sock_fd = socket(AF_INET, SOCK_STREAM, 0);      
24.         
25.   /* set non-blocking mode on socket*/      
26.  #if 1      
27.   flags = fcntl(sock_fd, F_GETFL, 0);      
28.   fcntl(sock_fd, F_SETFL, flags|O_NONBLOCK);      
29.  #else      
30.   int imode = 1;      
31.   ioctl(sock_fd, FIONBIO, &imode);      
32.  #endif      
33.            
34.   /* connect to server */      
35.   addr.sin_family  = AF_INET;      
36.   addr.sin_port  = htons(PEER_PORT);      
37.   addr.sin_addr.s_addr = inet_addr(PEER_IP);      
38.   int res = connect(sock_fd, (struct sockaddr *)&addr, sizeof(struct sockaddr_in));      
39.   if (0 == res)      
40.   {      
41.    printf("socket connect succeed immediately.\n");      
42.          ret = 0;      
43.   }      
44.   else      
45.   {      
46.      printf("get the connect result by select().\n");      
47.      if (errno == EINPROGRESS)      
48.      {      
49.              int times = 0;      
50.              while (times++ < 5)      
51.              {      
52.                  fd_set rfds, wfds;      
53.                  struct timeval tv;      
54.                        
55.                  printf("errno = %d\n", errno);      
56.                  FD_ZERO(&rfds);      
57.                  FD_ZERO(&wfds);      
58.                  FD_SET(sock_fd, &rfds);      
59.                  FD_SET(sock_fd, &wfds);      
60.                        
61.                  /* set select() time out */      
62.                  tv.tv_sec = 10;       
63.                  tv.tv_usec = 0;      
64.                  int selres = select(sock_fd + 1, &rfds, &wfds, NULL, &tv);      
65.                  switch (selres)      
66.                  {      
67.                      case -1:      
68.                          printf("select error\n");      
69.                          ret = -1;      
70.                          break;      
71.                      case 0:      
72.                          printf("select time out\n");      
73.                          ret = -1;      
74.                          break;      
75.                      default:      
76.                          if (FD_ISSET(sock_fd, &rfds) || FD_ISSET(sock_fd, &wfds))      
77.                          {      
78.                          #if 0 // not useable in linux environment, suggested in <<Unix network programming>>      
79.                              int errinfo, errlen;      
80.                              if (-1 == getsockopt(sock_fd, SOL_SOCKET, SO_ERROR, &errinfo, &errlen))      
81.                              {      
82.                                  printf("getsockopt return -1.\n");      
83.                                  ret = -1;      
84.                                  break;      
85.                              }      
86.                              else if (0 != errinfo)      
87.                              {      
88.                                  printf("getsockopt return errinfo = %d.\n", errinfo);      
89.                                  ret = -1;      
90.                                  break;      
91.                              }      
92.                                    
93.                              ret = 0;      
94.                              printf("connect ok?\n");      
95.                          #else      
96.                          #if 1      
97.                              connect(sock_fd, (struct sockaddr *)&addr, sizeof(struct sockaddr_in));      
98.                              int err = errno;      
99.                              if  (err == EISCONN)      
100.                              {      
101.                                  printf("connect finished 111.\n");      
102.                                  ret = 0;      
103.                              }      
104.                              else      
105.                              {      
106.                                  printf("connect failed. errno = %d\n", errno);      
107.                                  printf("FD_ISSET(sock_fd, &rfds): %d\n FD_ISSET(sock_fd, &wfds): %d\n", FD_ISSET(sock_fd, &rfds) , FD_ISSET(sock_fd, &wfds));      
108.                                  ret = errno;      
109.                              }      
110.                          #else      
111.                          char buff[2];      
112.                          if (read(sock_fd, buff, 0) < 0)      
113.                          {      
114.                              printf("connect failed. errno = %d\n", errno);      
115.                              ret = errno;      
116.                          }      
117.                          else      
118.                          {      
119.                              printf("connect finished.\n");      
120.                              ret = 0;      
121.                          }      
122.                          #endif      
123.                          #endif      
124.                          }      
125.                          else      
126.                          {      
127.                              printf("haha\n");      
128.                          }      
129.                  }      
130.                        
131.                  if (-1 != selres && (ret != 0))      
132.                  {      
133.                      printf("check connect result again... %d\n", times);      
134.                      continue;      
135.                  }      
136.                  else      
137.                  {      
138.                      break;      
139.                  }      
140.              }      
141.      }      
142.      else      
143.      {      
144.          printf("connect to host %s:%d failed.\n", PEER_IP, PEER_PORT);      
145.          ret = errno;      
146.      }      
147.    }       
148.    if (0 == ret)      
149.    {      
150.        send(sock_fd, "12345", sizeof("12345"), 0);      
151.    }      
152.    else      
153.    {      
154.        printf("connect to host %s:%d failed.\n", PEER_IP, PEER_PORT);      
155.    }      
156.            
157.    close(sock_fd);      
158.    return ret;      
159.  }    

上述代码可以解决问题了

Linux下常见的socket错误码：

EACCES, EPERM：用户试图在套接字广播标志没有设置的情况下连接广播地址或由于防火墙策略导致连接失败。

EADDRINUSE 98：Address already in use（本地地址处于使用状态）

EAFNOSUPPORT 97：Address family not supported by protocol（参数serv_add中的地址非合法地址）

EAGAIN：没有足够空闲的本地端口。

EALREADY 114：Operation already in progress（套接字为非阻塞套接字，并且原来的连接请求还未完成）

EBADF 77：File descriptor in bad state（非法的文件描述符）

ECONNREFUSED 111：Connection refused（远程地址并没有处于监听状态）

EFAULT：指向套接字结构体的地址非法。

EINPROGRESS 115：Operation now in progress（套接字为非阻塞套接字，且连接请求没有立即完成）

EINTR：系统调用的执行由于捕获中断而中止。

EISCONN 106：Transport endpoint is already connected（已经连接到该套接字）

ENETUNREACH 101：Network is unreachable（网络不可到达）

ENOTSOCK 88：Socket operation on non-socket（文件描述符不与套接字相关）

ETIMEDOUT 110：Connection timed out（连接超时）

（总结：其实只需要知道覅阻塞connect的方法即可，因为在不同的平台不同的操作系统需要不同的使用方法）