Linux socket非阻塞connect方法（一）

socket  non-blocking mode connect

        对于面向连接的socket类型(SOCK_STREAM,SOCK_SEQPACKET)，在读写数据之前必须建立连接，connect()函数用于完成面向连接的socket的建链过程，对于TCP，也就是三次握手过程。

connect()函数

头文件：

    #include<sys/types.h>

    #include<sys/socket.h>

声明：

    int connect (int sockfd,struct sockaddr * serv_addr,int addrlen);
功能：

    使用套接字sockfd建立到指定网络地址serv_addr的socket连接，参数addrlen为serv_addr指向的内存空间大小，即sizeof(struct sockaddr_in)。

返回值：

   1）成功返回0，表示连接建立成功（如服务器和客户端是同一台机器上的两个进程时，会发生这种情况）

   2）失败返回SOCKET_ERROR，相应的设置errno，通过errno获取错误信息。常见的错误有对方主机不可达或者超时错误，也可能是对方主机没有进程监听对应的端口。

非阻塞connect（non-block mode connect）

套接字执行I/O操作有阻塞和非阻塞两种模式。在阻塞模式下，在I/O操作完成前，执行操作的函数一直等候而不会立即返回，该函数所在的线程会阻塞在这里。相反，在非阻塞模式下，套接字函数会立即返回，而不管I/O是否完成，该函数所在的线程会继续运行。

客户端调用connect()发起对服务端的socket连接，如果客户端的socket描述符为阻塞模式，则connect()会阻塞到连接建立成功或连接建立超时（linux内核中对connect的超时时间限制是75s， Soliris 9是几分钟，因此通常认为是75s到几分钟不等）。如果为非阻塞模式，则调用connect()后函数立即返回，如果连接不能马上建立成功（返回-1），则errno设置为EINPROGRESS，此时TCP三次握手仍在继续。此时可以调用select()检测非阻塞connect是否完成。select指定的超时时间可以比connect的超时时间短，因此可以防止连接线程长时间阻塞在connect处。

select判断规则：

   1）如果select()返回0，表示在select()超时，超时时间内未能成功建立连接，也可以再次执行select()进行检测，如若多次超时，需返回超时错误给用户。

   2）如果select()返回大于0的值，则说明检测到可读或可写的套接字描述符。源自 Berkeley 的实现有两条与 select 和非阻塞 I/O 相关的规则：

        A) 当连接建立成功时，套接口描述符变成 可写（连接建立时，写缓冲区空闲，所以可写）

        B) 当连接建立出错时，套接口描述符变成 既可读又可写（由于有未决的错误，从而可读又可写）

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

        □对于Unix环境，可通过调用getsockopt来检测描述符集合是连接成功还是出错（此为《Unix Network Programming》一书中提供的方法，该方法在Linux环境上测试，发现是无效的）：

               A)如果连接建立是成功的，则通过getsockopt(sockfd,SOL_SOCKET,SO_ERROR,(char *)&error,&len) 获取的error 值将是0

               B)如果建立连接时遇到错误，则errno 的值是连接错误所对应的errno值，比如ECONNREFUSED，ETIMEDOUT 等

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

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

 

综上所述，这里总结一下非阻塞connect的实现过程。

非阻塞connect的实现过程

1. 创建套接字sockfd

[cpp] view plain copy

 

1. /* 1. obtain a socket */  
2. int sock_fd;  
3. sock_fd = socket(AF_INET, SOCK_STREAM, 0);  

2. 设置套接字为非阻塞模式

[cpp] view plain copy

 

1. /* 2. set non-blocking mode no socket */  
2. #if 1  
3. int flags = fcntl(sock_fd, F_GETFL, 0);  
4. fcntl(sock_fd, F_SETFL, flags|O_NONBLOCK);  
5. #else  
6. int imode = 1;  
7. ioctl(sock_fd, FIONBIO, &imode);  

3. 调用connect进行连接

[cpp] view plain copy

 

1. struct sockaddr_in addr;  
2. addr.sin_family = AF_INET;  
3. addr.sin_port   = htons(PEER_PORT);  
4. addr.sin_addr.s_addr = inet_addr(PEER_IP);  
5. int ret = connect(sock_fd, (struct sockaddr *)&addr, sizeof(struct sockaddr));  
6. if (0 == res)  
7. {  
8.   printf("socket connect succeed immediately.\n");  
9.   ret = 0;  
10. }  
11. else  
12. {  
13.   printf("get the connect result by select().\n");  
14.   if (errno == EINPROGRESS)  
15.   {  
16.     ....  
17.   }  
18. }  

connect会立即返回，可能返回成功，也可能返回失败。如果连接的服务器在同一台主机上，那么在调用connect 建立连接时，连接通常会立即建立成功（我们必须处理这种情况）。
4.调用select()，通过FD_ISSET()检查套接口是否可写，确定连接请求是否完成

[cpp] view plain copy

 

1. fd_set rfds, wfds;  
2. struct timeval tv;  
3.   
4. FD_ZERO(&rfds);FD_ZERO(&wfds);  
5. FD_SET(sock_fd, &rfds);  
6. FD_SET(sock_fd, &wfds);  
7. /* set select() time out */  
8. tv.tv_sec = 10;   
9. tv.tv_usec = 0;  
10. int selres = select(sock_fd + 1, &rfds, &wfds, NULL, &tv);  
11. switch (selres)  
12. {  
13.     case -1:  
14.         printf("select error\n");  
15.         ret = -1;  
16.         break;  
17. case 0:  
18.        printf("select time out\n");  
19.        ret = -1;  
20.        break;  
21. default:  
22.        if (FD_ISSET(sock_fd, &rfds) || FD_ISSET(sock_fd, &wfds))  
23.        {  
24.            .....  
25.        }  
26. }  

对于无连接的socket类型(SOCK_DGRAM)，客户端也可以调用connect进行连接,此连接实际上并不建立类似SOCK_STREAM的连接，而仅仅是在本地保存了对端的地址，这样后续的读写操作可以默认以连接的对端为操作对象。

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（连接超时）

 

测试代码：

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

顶

0

踩