1.采用select
在学习嵌入式Linux网络编程中，很多同学都发现了一个问题，那就是调用connect函数时，如果服务端关闭，客户 端调用connect（）函数时，发现阻塞在那里，而且利用ctrl+c信号去停止客户端程序时，需要等待一个较为长的时间才能响应了，这个时间如果大家 细心会发现，每次都是75秒的时间。那么有没有什么比较好的办法，可以以用户能接受的一个时间响应来停止掉一个正在connect连接的客户端那？比如我 们在做一个网络控制台的程序，用户需要随时可以停止掉任何一个网络服务连接，那么对于这样一个需要等待75秒时间才能反馈出服务状态的程序，用户是无法接 受的。
对于如何解决这个问题，我们可以分析下，要想完成用户在一个能接受的时间里迅速反馈出服务 端已经关闭的状态，那么我们的程序应该做到在一个规定的时间片内，可以捕获到用户发出的控制状态，然后处理用户的需求。那么要做到可以在规定的时间片内捕 获用户的控制状态，就必须禁止让我们的connect（）函数阻塞75秒的情况发生，也就是说，要让connect（）函数变为非阻塞状态才行。
好了，现在解决问题的关键就是如何把connect变为非阻塞状态了，我们知道，socket编程的操作对象是socket，而socket他又属于系统描述符类型，那么对于系统描述符，我们是怎么操作他变为非阻塞的那？是利用fcntl（）函数或者ioctl（）函数。
想到这里，好像问题应该已经解决了，但是我们调试发现，在服务端出现错误的时候，connect确实马上返回，但是，如果服务端正确那，connect还是马上返回，这样，我们无法判断connect函数是否成功了，那这个问题又该如何解决呢？
我们是否想到了一个select函数那，他具备监听文件描述符的功能，如果我们把之前的socket让select监听他是否可写，是不是问题也就解决了。
好了，那么我们总结下整个思路：
1．建立socket
2．将该socket设置为非阻塞模式
3．调用connect()
4．使用select()检查该socket描述符是否可写
5．根据select()返回的结果判断connect()结果
6．将socket设置为阻塞模式
对于第六步，为什么还要设置为阻塞模式那，留给我们同学自己思考下。
那么根据上面的6个步骤，我们写一个简单的模块程序来调试看下：
{
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if(sockfd < 0) exit(1);
struct sockaddr_in serv_addr;
………//以服务器地址填充结构serv_addr
int error=-1, len;
len = sizeof(int);
timeval tm;
fd_set set;
unsigned long ul = 1;
ioctl(sockfd, FIONBIO, &ul); //设置为非阻塞模式
bool ret = false;
if( connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1)
{
tm.tv_set = TIME_OUT_TIME;
tm.tv_uset = 0;
FD_ZERO(&set);
FD_SET(sockfd, &set);
if( select(sockfd+1, NULL, &set, NULL, &tm) > 0)
{
getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, (socklen_t *)&len);
if(error == 0) ret = true;
else ret = false;
} else ret = false;
}
else ret = true;
ul = 0;
ioctl(sockfd, FIONBIO, &ul); //设置为阻塞模式
//下面还可以进行发包收包操作
……………
}
2.方法二、定义信号处理函数：
sigset(SIGALRM, u_alarm_handler);
alarm(2);
code = connect(socket_fd, (struct sockaddr*)&socket_st, sizeof(struct sockaddr_in));
alarm(0);
sigrelse(SIGALRM);
首先定义一个中断信号处理函数u_alarm_handler，用于超时后的报警处理，然后定义一个2秒的定时器，执行connect，当系统 connect成功，则系统正常执行下去；如果connect不成功阻塞在这里，则超过定义的2秒后，系统会产生一个信号，触发执行 u_alarm_handler函数， 当执行完u_alarm_handler后，程序将继续从connect的下面一行执行下去。
其中，处理函数可以如下定义，也可以加入更多的错误处理。
void u_alarm_handler()
{
}
非阻塞socket的连接 connect
连接套接字，阻塞的套接字超时时间很长无法接受，而是用非阻塞套接字时使用的方案也有多种。后者是个比较好的方法
方案1：不断重试，直到连接上或者超时：
int connect_socket_timeout(int sockfd,char *dest_host, int port, int timeout)
{
struct sockaddr_in address;
struct in_addr inaddr;
struct hostent *host;
int err, noblock=1 , connect_ok=0, begin_time=time(NULL);
log_debug(“connect_socket to %s:%dn”,dest_host,port);
if (inet_aton(dest_host, &inaddr))
{
log_debug(“inet_aton ok now gethostbyaddr %sn”,dest_host);
memcpy(&address.sin_addr, &inaddr, sizeof(address.sin_addr));
}
else
{
log_debug(“inet_aton fail now gethostbyname %s n”,dest_host);
host = gethostbyname(dest_host);
if (!host) {
/* We can’t find an IP number */
log_error(“error looking up host %s : %dn”,dest_host,errno);
return -1;
}
memcpy(&address.sin_addr, host->h_addr_list[0], sizeof(address.sin_addr));
}
address.sin_family = AF_INET;
address.sin_port = htons(port);
/* Take the first IP address associated with this hostname */
ioctl(sockfd,FIONBIO,&noblock);
/* connect until timeout /
/*
EINPROGRESS A nonblocking socket connection cannot be completed immediately.
EALREADY The socket is nonblocking and a previous connection attempt has not been completed.
EISCONN The socket is already connected.
*/
if (connect(sockfd, (struct sockaddr *) &address, sizeof(address)) < 0)
{
err = errno;
if (err != EINPROGRESS)
{
log_error(“connect = %d connecting to host %sn”, err,dest_host);
}
else
{
// log_notice(“connect pending, return %d n”, err);
while (1) /* is noblocking connect, check it until ok or timeout */
{
connect(sockfd, (struct sockaddr *) &address, sizeof(address));
err = errno;
switch (err)
{
case EISCONN: /* connect ok */
connect_ok = 1;
break;
case EALREADY: /* is connecting, need to check again */
//log_info(“connect again return EALREADY check again…n”);
usleep(50000);
break;
default: /* failed, retry again ? */
log_error(“connect fail err=%d n”,err);
connect_ok = -1;
break;
}
if (connect_ok==1)
{
//log_info (“connect ok try time =%d n”, (time(NULL) - begin_time) );
break;
}
if (connect_ok==-1)
{
log_notice (“connect failed try time =%d n”, (time(NULL) - begin_time) );
}
if ( (timeout>0) && ((time(NULL) - begin_time)>timeout) )
{
log_notice(“connect failed, timeout %d secondsn”, (time(NULL) - begin_time));
break;
}
}
}
}
else /* Connect successful immediately */
{
// log_info(“connect immediate success to host %sn”, dest_host);
connect_ok = 1;
}
/* end of try connect /
return ((connect_ok==1)?sockfd:-1);
}
方案2：
补充关于select在异步(非阻塞)connect中的应用,刚开始搞socket编程的时候我一直都用阻塞式的connect,非阻塞connect的问题是由于当时搞proxy scan
而提出的呵呵，通过在网上与网友们的交流及查找相关FAQ,总算知道了怎么解决这一问题.同样用select可以很好地解决这一问题.大致过程是这样的:
1.将打开的socket设为非阻塞的,可以用fcntl(socket, F_SETFL, O_NDELAY)完成(有的系统用FNEDLAY也可).
2.发connect调用,这时返回-1,但是errno被设为EINPROGRESS,意即connect仍旧在进行还没有完成.
3.将打开的socket设进被监视的可写(注意不是可读)文件集合用select进行监视,如果可写,用getsockopt(socket, SOL_SOCKET, SO_ERROR, &error, sizeof(int));
来得到error的值,如果为零,则connect成功.
在许多unix版本的proxyscan程序你都可以看到类似的过程,另外在solaris精华区->编程技巧中有一个通用的带超时参数的connect模块.
我们知道，缺省状态下的套接字都是阻塞方式的，这意味着一个套接口的调用不能立即完成时，进程将进入睡眠状态，并等待操作完成。对于某些应用，需要及时可控的客户响应，而阻塞的方式可能会导致一个较长的时间段内，连接没有响应。造成套接字阻塞的操作主要有recv, send, accept, connect.
下面主要以connect为例，讲讲非阻塞的connect的工作原理。当一个TCP套接字设置为非阻塞后，调用connect，会立刻返回一个EINPROCESS的错误。但TCP的三路握手继续进行，我们将用select函数检查这个连接是否建立成功。建立非阻塞的connect有下面三个用途：
1.可以在系统做三路握手的时候做些其它事情，这段时间你可以为所欲为。
2 可以用这个技术同时建立多个连接，在web应用中很普遍。
3.可以缩短connect的超时时间，多数实现中，connect的超时在75秒到几分钟之间，累傻小子呢？
虽然非阻塞的conncet实现起来并不复杂，但我们必须注意以下的细节:
* 即使套接字是非阻塞的，如果连接的服务器是在同一台主机，connect通常会立刻建立。(connect 返回 0 而不是 EINPROCESS)
* 当连接成功建立时，描述字变成可写
* 当连接出错时，描述字变成可读可写
int connect_nonb(int sockfd, const SA *saptr, socklen_t salen, int nsec)
{
int flags, n, error;
socklen_t len;
fd_set rset, wset;
struct timeval tval;
// 获取当前socket的属性， 并设置 noblocking 属性
flags = fcntl(sockfd, F_GETFL, 0);
fcntl(sockfd, F_SETFL, flags | O_NOBLOCK);
errno = 0;
if ( (n = connect(sockfd, saptr, salen)) < 0)
if (errno != EINPROGRESS)
return (-1);
// 可以做任何其它的操作
if (n == 0)
goto done; // 一般是同一台主机调用，会返回 0
FD_ZERO(&rset);
FD_SET(sockfd, &rset);
wset = rset; // 这里会做 block copy
tval.tv_sec = nsec;
tval.tv_usec = 0;
// 如果nsec 为0，将使用缺省的超时时间，即其结构指针为 NULL
// 如果tval结构中的时间为0，表示不做任何等待，立刻返回
if ((n = select(sockfd+1, &rset, &west, NULL,nsec ?tval:NULL)) == 0) {
close(sockfd);
errno = ETIMEOUT;
return (-1);
}
if(FD_ISSET(sockfd, &rset) || FD_ISSET(sockfd, &west)) {
len = sizeof(error);
// 如果连接成功，此调用返回 0
if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, &len) < 0)
return (-1);
}
else
err_quit(“select error: sockfd not set”);
done:
fcntl(sockfd, F_SETFL, flags); // 恢复socket 属性
if (error) {
close(sockfd);
errno = error;
return (-1);
}
return (0);
}
现在在网络服务器编程中使用epoll比较普遍，创建一个socket，设为异步socket（fcntl），
connect到远端（此时connect调用返回非0，但errno为EINPROGRESS，表示正在建立连接中）
由epoll负责监听fd的状态，epoll_wait之捕获到EPOLLOUT事件，收到EPOLLOUT也不能认为是
TCP层次上connect(2)已经成功，要调用getsockopt看SOL_SOCKET的SO_ERROR是否为0。若为0，
才表明真正的TCP层次上connect成功。至于应用层次的server是否收/发数据，那是另一回事了。
我们知道，Linux下socket编程有常见的几个系统调用：
对于服务器来说， 有socket（）， bind（），listen（）, accept（），read（），write（）
对于客户端来说，有socket（），connect（）
这里主要要讲的是客户端这边的connect函数。
对于客户端来说，需要打开一个套接字，然后与对端服务器连接，例如：
1 int main(int argc, char **argv)
2 {
3 struct sockaddr_in s_addr;
4 memset(&s_addr, 0, sizeof(s_addr));
5 s_addr.sin_family = AF_INET;
6 s_addr.sin_addr.s_addr = inet_addr(“remote host”);
7 s_addr.sin_port = htons(remote port);
8 socklen_t addr_len = sizeof(struct sockaddr);
9 int c_fd = socket(AF_INET, SOCK_STREAM, 0);
10 int ret = connect(c_fd, (struct sockaddr*)&s_addr, addr_len);
11 ……
12 }
当connect上对端服务器之后，就可以使用该套接字发送数据了。
我们知道，如果socket为TCP套接字， 则connect函数会激发TCP的三次握手过程，而三次握手是需要一些时间的，内核中对connect的超时限制是75秒，就是说如果超过75秒则connect会由于超时而返回失败。但是如果对端服务器由于某些问题无法连接，那么每一个客户端发起的connect都会要等待75才会返回，因为socket默认是阻塞的。对于一些线上服务来说，假设某些对端服务器出问题了，在这种情况下就有可能引发严重的后果。或者在有些时候，我们不希望在调用connect的时候阻塞住，有一些额外的任务需要处理；
这种场景下，我们就可以将socket设置为非阻塞，如下代码：
int flags = fcntl(c_fd, F_GETFL, 0);
if(flags < 0) {
return 0;
}
fcntl(c_fd, F_SETFL, flags | O_NONBLOCK);
当我们将socket设置为NONBLOCK后，在调用connect的时候，如果操作不能马上完成，那connect便会立即返回，此时connect有可能返回-1， 此时需要根据相应的错误码errno，来判断连接是否在继续进行。
当errno=EINPROGRESS时，这种情况是正常的，此时连接在继续进行，但是仍未完成;同时TCP的三路握手操作继续进行；后续只要用select/epoll去注册对应的事件并设置超时时间来判断连接否是连接成功就可以了。
int ret = connect(c_fd, (struct sockaddr*)&s_addr, addr_len);
while(ret < 0) {
if( errno == EINPROGRESS ) {
break;
} else {
perror(“connect fail’\n”);
return 0;
}
}
复制代码
这个地方，我们很可能会判断如果ret小于0，就直接判断连接失败而返回了，没有根据errno去判断EINPROGRESS这个错误码。这里也是昨天在写份程序的时候遇到的一个坑。
使用非阻塞 connect 需要注意的问题是：
1. 很可能 调用 connect 时会立即建立连接（比如，客户端和服务端在同一台机子上），必须处理这种情况。
2. Posix 定义了两条与 select 和 非阻塞 connect 相关的规定：
1）连接成功建立时，socket 描述字变为可写。（连接建立时，写缓冲区空闲，所以可写）
2）连接建立失败时，socket 描述字既可读又可写。 （由于有未决的错误，从而可读又可写）
不过我同时用epoll也做了实验(connect一个无效端口，errno=110, errmsg=connect refused)，当连接失败的时候，会触发epoll的EPOLLERR与EPOLLIN，不会触发EPOLLOUT。
当用select检测连接时，socket既可读又可写，只能在可读的集合通过getsockopt获取错误码。
当用epoll检测连接时，socket既可读又可写，只能在EPOLLERR中通过getsockopt获取错误码。
完整代码如下：
复制代码
/*
* File: main.cpp
* Created on March 7, 2013, 5:54 PM
*/
include
include
include
include
include
include
include
include
include
include
include
include
