12.I/O超时设置方法
一. 使用alarm函数设置超时
#include
unsigned int alarm(unsigned int seconds);
alarm也称为闹钟函数，它可以在进程中设置一个定时器，当定时器指定的时间到时，它向进程发送SIGALRM信号。如果忽略或者不捕获此信号，则其默认动作是终止调用该alarm函数的进程。
要注意的是，一个进程只能有一个闹钟时间，如果在调用alarm之前已设置过闹钟时间，则任何以前的闹钟时间都被新值所代替。需要注意的是，经过指定的秒数后，信号由内核产生，由于进程调度的延迟，所以进程得到控制从而能够处理该信号还需要一些时间。
void handle(int sig)
{
}
signal(SIGALRM,handler);
alarm(5);
int ret = read(fd,buf,sizeof(buf));
if(ret == -1 && errno == EINTR)
errno=ETIMEOUT;
else if(ret >=0)
alarm(0); http://write.blog.csdn.net/postedit/40829321像上面那样,如果在5s内被SIGALRM信号中断,表示超时,否则,已经读取到数据.但是这么方法在网络编程中不太常用, 因为有时可能在其他地方使用了alarm会造成混乱。
二. 使用套接字选项SO_SNDTIMEO,SO_RECVTIMEO实现超时
struct timeval timeout={3,0};
setsockopt(sock,SOL_SOCKET,SO_RECVTIME0,(char*)&timeout,sizeof(struct timeval));
int ret=read(sock,buf,sizeof(buf));
if(ret == -1 && errno==EWOULDBLOCK)
ERRNO=ETIMEOUT;即使用setsockopt 函数进行设置，但这种方法可移植性比较差，不是每种系统实现都有这些选项。
三. 使用select实现超时
(1) read_timeout
/*
read_time-------读超时检测函数,不含读操作
fd--------------文件描述符
wait_seconds----等待的秒数,
成功(未超时)返回0,失败返回-1, 超时返回-1,并且errno=ETIMEDOUT
如果读擦做超时(失败),不进行
如果成功,进行读操作
*/
int read_timeout(int fd,unsigned int wait_seconds)
{
int ret=0;
if(wait_seconds > 0)
{
fd_set read_fdset;// 读的文件描述符集合
struct timeval timeout;// 超时时间结构提体
FD_ZERO(&read_fdset);//初始话集合
FD_SET(fd,&read_fdset);
timeout.tv_sec = wait_seconds;
timeout.tv_usec = 0;
do
{
ret = select(fd+1,&read_fdset,NULL,NULL,&timeout);//select会阻塞直到检测到事件或者超时
// 如果selcel检测到可读事件,，则此时调用read不会阻塞
}while(ret < 0 && errno == EINTR);
if(ret == 0)
{
ret = -1;
errno = ETIMEDOUT;
}
else if(ret == 1)// 检测到一个事件
return 0;
}
return ret;
}简析: read_time,只是超时检测函数,没有读操作,如果从此函数成功返回，则此时调用read将不再阻塞.
如果 read_timeout(fd, 0); 则表示不检测超时，函数直接返回为0，此时再调用read 将会阻塞。
当wait_seconds 参数大于0，则进入if 括号执行，将超时时间设置为select函数的超时时间结构体，select会阻塞直到检测到事件发生或者超时。如果select返回-1且errno 为EINTR，说明是被信号中断，需要重启select；如果select返回0表示超时；如果select返回1表示检测到可读事件；否则select返回-1 表示出错。
应用模式:
int ret;
ret = read_timeout(fd,5);
if(ret == 0)//未超时或不检测超时
{
read(fd,....);
}
else if(ret ==-1 && errno == ETIMEDOUT)// 超时
{
printf("timeout...\n");
}
els
{
ERR_EXIT("READ_EXIT");
}(2)write_timeout
/*
write_timeout-------写超时检测函数,不含读操作
fd--------------文件描述符
wait_seconds----等待的秒数,
成功(未超时)返回0,失败返回-1, 超时返回-1,并且errno=ETIMEDOUT
*/
int write_timeout(int fd,unsigned int wait_seconds)
{
int ret=0;
if(wait_seconds > 0)
{
fd_set write_fdset;
struct timeval timeout;
FD_ZERO(&write_fdset);
FD_SET(fd,&write_fdset);
timeout.tv_sec = wait_seconds;
timeout.tv_usec = 0;
do
{
ret = select(fd+1,NULL,&write_fdset,NULL,&timeout);
}while(ret<0 && errno == EINTR);
if(ret == 0)
{
ret = -1;
errno = ETIMEDOUT;
}
else if(ret == 1)
return 0;
}
return ret;
}(3)accept_timeout
/*
accept_time-------带超时的accept
fd--------------文件描述符
wait_seconds----等待的秒数,
成功(未超时)返回0,失败返回-1, 超时返回-1,并且errno=ETIMEDOUT
*/
int accept_timeout(int fd,struct sockaddr_in *addr,unsigned int wait_seconds)
{
int ret;
socklen_t addrlen = sizeof(struct sockaddr_in);
if(wait_seconds > 0)
{
fd_set accept_fdset; //创建accept文件描述集合
struct timeval timeout;
FD_ZERO(&accept_fdset);
FD_SET(fd,&accept_fdset);
timeout.tv_sec = wait_seconds;
timeout.tv_usec= 0;
do
{
ret = select(fd+1,&accept_fdset,NULL,NULL,&timeout);
}while(ret <0 && errno==EINTR);//EINTR表示信号中断
if(ret == -1)
return -1;
else if(ret == 0)
{
errno = ETIMEDOUT;// 连接时间超出
return -1;
}
}
//执行到这里,已经检测到事件
if(addr != NULL)
ret = accept(fd,(struct sockaddr*)addr,&addrlen);
else
ret = accept(fd,NULL,NULL);
if(ret== -1)
ERR_EXIT("accept err");
return ret;
}
解析: accept_timeout ：此函数是带超时的accept 函数，如果能从if (wait_seconds > 0) 括号执行后向下执行，说明select 返回为1，检测到已连接队列不为空，此时再调用accept 不再阻塞，当然如果wait_seconds == 0 则像正常模式一样，accept 阻塞等待，注意，accept 返回的是已连接套接字。
(4)connect_timeout
非阻塞I/O使我们的操作要么成功，要么立即返回错误，不被阻塞。
对于一个给定的描述符两种方法对其指定非阻塞I/O:
(1)调用open获得描述符，并指定O_NONBLOCK标志
(2)对已经打开的文件描述符，调用fcntl，打开O_NONBLOCK文件状态标志。
flags = fcntl( s, F_GETFL, 0 ) )
fcntl( s, F_SETFL, flags | O_NONBLOCK )
--------------------------------------------------------------------------------------
fcntl的返回值与命令有关。如果出错，所有命令都返回-1，如果成功则返回某个其他值。下列四个命令有特定返回值：F_DUPFD、F_GETFD、F_GETFL、F_GETOWN.第一个返回新的文件描述符，接下来的两个返回相应标志，最后一个返回一个正的进程ID或负的进程组ID。
//activate_nonblock --- 设置IO为非阻塞模式
void activate_nonblock(int fd)
{
int ret;
int flags = fcntl(fd,F_GETFL,NULL);
if( flags == -1)
ERR_EXIT("fcntl error");
flags |= O_NONBLOCK;
ret = fcntl(fd,F_SETFL,flags);
if(ret == -1)
ERR_EXIT("fcntl error");
}
/*
deactivate_nonblock ----设置IO为阻塞模式
*/
void deactivate_nonblock(int fd)
{
int ret;
int flags = fcntl(fd,F_GETFL,NULL);
if(flags == -1)
ERR_EXIT("fcntl error");
flags &= ~O_NONBLOCK;
ret = fcntl(fd,F_SETFL,flags);
if( ret == -1)
ERR_EXIT("fcntl error");
}
/*
connect_timeout ----带超市的connect
addr: 输出参数,返回对方地址
wait_seconds: 等待超时秒数，如果为0表示正常模式
成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT
*/
int connect_timeout(int fd,struct sockaddr_in *addr,unsigned int wait_seconds)
{
int ret;
socklen_t addrlen = sizeof(struct sockaddr_in);
if(wait_seconds > 0)
activate_nonblock(fd);//设置IO为非阻塞模式
ret = connect(fd,(struct sockaddr*)addr,addrlen);
if(ret < 0 && errno == EINPROGRESS)//Linux 非阻塞connect，错误码：EINPROGRESS,连接正在处理当中
{
printf("aaaaaaaa\n");
fd_set connect_fdset;
struct timeval timeout;
FD_ZERO(&connect_fdset);
FD_SET(fd,&connect_fdset);
timeout.tv_sec = wait_seconds;
timeout.tv_usec = 0;
do
{
// 这里select使用写集合,因为一旦建立连接,套接字就写
ret = select(fd+1,NULL,&connect_fdset,NULL,&timeout);
}while(ret<0 && errno==EINTR);
if(ret == 0)
{
errno = ETIMEDOUT;// 连接超时
return -1;
}
else if(ret <0)
return -1;
else if(ret == 1)
{
//ret返回为1，可能有两种情况，
//一种是连接建立成功，
//一种是套接字产生错误
// 此时错误信息不会保存至errno变量中（select没出错）,因此，
// 需要调用getsockopt来获取
// 获取套接字的错误
printf("bbbbbbbbbbb\n");
int err;
socklen_t socklen = sizeof(err);
int sockoptret = getsockopt(fd,SOL_SOCKET,SO_ERROR,&err,&socklen);
if( sockoptret == -1)
return -1;
if( err == 0)//没有错误
{
printf("dddddddddd\n");
ret = 0;
}
else// 产生错误
{
printf("cccccccccc\n");
errno = err;
ret = -1;
}
}
}
if(wait_seconds > 0)/// 重新置为阻塞模式
deactivate_nonblock(fd);
return ret;
}
解析: 在调用connect前需要使用fcntl 函数将套接字标志设置为非阻塞，如果网络环境很好，则connect立即返回0，不进入if 大括号执行；如果网络环境拥塞，则connect返回-1且errno == EINPROGRESS，表示正在处理。此后调用select与前面3个函数类似，但这里关注的是可写事件，因为一旦连接建立，套接字就可写。还需要注意的是当select 返回1，可能有两种情况，一种是连接成功，一种是套接字产生错误,这两种情况都会产生可写事件，所以需要使用getsockopt来获取一下。退出之前还需重新将套接字设置为阻塞。
完整的C/S测试程序如下:
服务器程序:
/// srv.c
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define ERR_EXIT(m) \
do { \
perror(m); \
exit(EXIT_FAILURE); \
} while (0)
int main()
{
int listenfd;
printf("%d",INADDR_ANY);
if((listenfd = socket(PF_INET,SOCK_STREAM,0)) < 0)
ERR_EXIT("socket err");
struct sockaddr_in servaddr;
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(5188);
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
// 设定地址重复利用
int on=1;
if(setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on)) < 0)
ERR_EXIT("setsockopt err");
if(bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr)) < 0)
ERR_EXIT("bind err");
if(listen(listenfd,SOMAXCONN) < 0)
ERR_EXIT("listen err");
struct sockaddr_in peeraddr;
socklen_t peerlen=sizeof(peeraddr);
int conn;
if((conn = accept(listenfd,(struct sockaddr*)&peeraddr,&peerlen)) < 0)
ERR_EXIT("accept err");
//连接成功,打印对方IP地址
printf("ip=%s ,port=%d\n",inet_ntoa(peeraddr.sin_addr),ntohs(peeraddr.sin_port));
return 0;
}
客户端程序:
// sys.h
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define ERR_EXIT(m) \
do { \
perror(m); \
exit(EXIT_FAILURE); \
} while (0)
/*
read_time-------读超时检测函数,不含读操作
fd--------------文件描述符
wait_seconds----等待的秒数,
成功(未超时)返回0,失败返回-1, 超时返回-1,并且errno=ETIMEDOUT
如果读擦做超时(失败),不进行
如果成功,进行读操作
*/
int read_timeout(int fd,unsigned int wait_seconds)
{
int ret=0;
if(wait_seconds > 0)
{
fd_set read_fdset;// 读的文件描述符集合
struct timeval timeout;// 超时时间结构提体
FD_ZERO(&read_fdset);//初始话集合
FD_SET(fd,&read_fdset);
timeout.tv_sec = wait_seconds;
timeout.tv_usec = 0;
do
{
ret = select(fd+1,&read_fdset,NULL,NULL,&timeout);//select会阻塞直到检测到事件或者超时
// 如果selcel检测到可读事件,，则此时调用read不会阻塞
}while(ret < 0 && errno == EINTR);
if(ret == 0)
{
ret = -1;
errno = ETIMEDOUT;
}
else if(ret == 1)// 检测到一个事件
return 0;
}
return ret;
}
/*
write_timeout-------写超时检测函数,不含读操作
fd--------------文件描述符
wait_seconds----等待的秒数,
成功(未超时)返回0,失败返回-1, 超时返回-1,并且errno=ETIMEDOUT
*/
int write_timeout(int fd,unsigned int wait_seconds)
{
int ret=0;
if(wait_seconds > 0)
{
fd_set write_fdset;
struct timeval timeout;
FD_ZERO(&write_fdset);
FD_SET(fd,&write_fdset);
timeout.tv_sec = wait_seconds;
timeout.tv_usec = 0;
do
{
ret = select(fd+1,NULL,&write_fdset,NULL,&timeout);
}while(ret<0 && errno == EINTR);
if(ret == 0)
{
ret = -1;
errno = ETIMEDOUT;
}
else if(ret == 1)
return 0;
}
return ret;
}
/*
accept_time-------带超时的accept
fd--------------文件描述符
wait_seconds----等待的秒数,
成功(未超时)返回0,失败返回-1, 超时返回-1,并且errno=ETIMEDOUT
*/
int accept_timeout(int fd,struct sockaddr_in *addr,unsigned int wait_seconds)
{
int ret;
socklen_t addrlen = sizeof(struct sockaddr_in);
if(wait_seconds > 0)
{
fd_set accept_fdset; //创建accept文件描述集合
struct timeval timeout;
FD_ZERO(&accept_fdset);
FD_SET(fd,&accept_fdset);
timeout.tv_sec = wait_seconds;
timeout.tv_usec= 0;
do
{
ret = select(fd+1,&accept_fdset,NULL,NULL,&timeout);
}while(ret <0 && errno==EINTR);//EINTR表示信号中断
if(ret == -1)
return -1;
else if(ret == 0)
{
errno = ETIMEDOUT;// 连接时间超出
return -1;
}
}
//执行到这里,已经检测到事件
if(addr != NULL)
ret = accept(fd,(struct sockaddr*)addr,&addrlen);
else
ret = accept(fd,NULL,NULL);
if(ret== -1)
ERR_EXIT("accept err");
return ret;
}
//activate_nonblock --- 设置IO为非阻塞模式
void activate_nonblock(int fd)
{
int ret;
int flags = fcntl(fd,F_GETFL,NULL);
if( flags == -1)
ERR_EXIT("fcntl error");
flags |= O_NONBLOCK;
ret = fcntl(fd,F_SETFL,flags);
if(ret == -1)
ERR_EXIT("fcntl error");
}
/*
deactivate_nonblock ----设置IO为阻塞模式
*/
void deactivate_nonblock(int fd)
{
int ret;
int flags = fcntl(fd,F_GETFL,NULL);
if(flags == -1)
ERR_EXIT("fcntl error");
flags &= ~O_NONBLOCK;
ret = fcntl(fd,F_SETFL,flags);
if( ret == -1)
ERR_EXIT("fcntl error");
}
/*
connect_timeout ----带超市的connect
addr: 输出参数,返回对方地址
wait_seconds: 等待超时秒数，如果为0表示正常模式
成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT
*/
int connect_timeout(int fd,struct sockaddr_in *addr,unsigned int wait_seconds)
{
int ret;
socklen_t addrlen = sizeof(struct sockaddr_in);
if(wait_seconds > 0)
activate_nonblock(fd);//设置IO为非阻塞模式
ret = connect(fd,(struct sockaddr*)addr,addrlen);
if(ret < 0 && errno == EINPROGRESS)//Linux 非阻塞connect，错误码：EINPROGRESS,连接正在处理当中
{
//// printf("aaaaaaaa\n");
fd_set connect_fdset;
struct timeval timeout;
FD_ZERO(&connect_fdset);
FD_SET(fd,&connect_fdset);
timeout.tv_sec = wait_seconds;
timeout.tv_usec = 0;
do
{
// 这里select使用写集合,因为一旦建立连接,套接字就写
ret = select(fd+1,NULL,&connect_fdset,NULL,&timeout);
}while(ret<0 && errno==EINTR);
if(ret == 0)
{
errno = ETIMEDOUT;// 连接超时
return -1;
}
else if(ret <0)
return -1;
else if(ret == 1)
{
//ret返回为1，可能有两种情况，
//一种是连接建立成功，
//一种是套接字产生错误
// 此时错误信息不会保存至errno变量中（select没出错）,因此，
// 需要调用getsockopt来获取
// 获取套接字的错误
//// printf("bbbbbbbbbbb\n");
int err;
socklen_t socklen = sizeof(err);
int sockoptret = getsockopt(fd,SOL_SOCKET,SO_ERROR,&err,&socklen);
if( sockoptret == -1)
return -1;
if( err == 0)//没有错误
{
//printf("dddddddddd\n");
ret = 0;
}
else// 产生错误
{
//printf("cccccccccc\n");
errno = err;
ret = -1;
}
}
}
if(wait_seconds > 0)/// 重新置为阻塞模式
deactivate_nonblock(fd);
return ret;
}
/////cli.c
#include "sys.h"
int main()
{
int sock;
if((sock = socket(PF_INET,SOCK_STREAM,IPPROTO_TCP)) < 0)
ERR_EXIT("socket err");
struct sockaddr_in servaddr;
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(5188);
servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
int ret = connect_timeout(sock,&servaddr,5);
if(ret == -1 && errno == ETIMEDOUT)
{
printf("timeout ... \n");
return 1;
}
else if(ret == -1)
ERR_EXIT("connect_timeout err");
struct sockaddr_in localaddr;
socklen_t addrlen = sizeof(localaddr);
if( getsockname(sock,(struct sockaddr *)&localaddr,&addrlen) <0)
ERR_EXIT("getsockname err");
printf("ip=%s,port=%d\n",inet_ntoa(localaddr.sin_addr),ntohs(localaddr.sin_port));
return 0;
}
Makefile:
.PHONY:clean all
CC=gcc
CFLAGS=-Wall -g
BIN=srv cli 1 #echoser echocli echocli2 echoser2
all:$(BIN)
%.o:%.c
$(cc) $(CFLAGS) -c $< -o $@ #$< 当前依赖的文件名,$@当前目标的文件名
clean:
rm -f *.o $(BIN)