今天继续学习socket编程,这次主要是学习超时方法的封装,内容如下:
![](https://i-blog.csdnimg.cn/blog_migrate/e3a74a58b9b3c359ec92e031c41461d2.png)
①、alarm【不常用,了解既可】
它的实现思路是这样的:
![](https://i-blog.csdnimg.cn/blog_migrate/1c18d4c3efc78fefc1a8df5e84b0641a.png)
但是这种方案有一定的问题,因为闹钟可能会作为其它的用途,这时所设置的闹钟跟其它用途的闹钟会产生冲突,而这些冲突的解决,会比较麻烦,这里就不多讨论了,因为不使用它,仅了解既可,是不会用闹钟的方式来实现超时的。
②、套接字选项【不常用,了解既可】
SO_SNDTIMEO:发送的超时时间
SO_RCVTIMEO:接收的超时时间
具体实现思路是这样的:
![](https://i-blog.csdnimg.cn/blog_migrate/bae06c68f4516a3204ae9905331c8431.png)
但是,也不会用这种方式,因为存在移植兼容的问题。
③、select【常用,这次学习的重点】
read_timeout函数封装:
下面会仔细分析是如何封装的,在封装之后,先看下函数原形:
![](https://i-blog.csdnimg.cn/blog_migrate/ecfedaad083bfd294245b9561c9098f5.png)
所以,先不关心它是如何实现的,依照这个函数原形,其使用方法如下【伪代码】:
![](https://i-blog.csdnimg.cn/blog_migrate/e2c093e7d79e6f9c3360d9e9b3c31fc1.png)
另外,如果想按照正常的方式来处理,可以将超时参数传0既可,如下:
![](https://i-blog.csdnimg.cn/blog_migrate/34b43157b28f27dd579835aac32e40c0.png)
下面将整个函数的实现贴出来,比较容易理解,这里就不一一赘述了,里面的注释比较详细:
/**
* read_timeout - 读超时检测函数,不含读操作
* @fd: 文件描述符
* @wait_seconds: 等待超时秒数,如果为0表示不检测超时
* 成功(未超时)返回0,失败返回-1,超时返回-1并且errno = ETIMEDOUT
*/
int read_timeout(int fd, unsigned int wait_seconds)
{
int ret = 0;//默认返回值为0,也就是未超时
if (wait_seconds > 0)
{//如果当传过来的超时时间大于0时才做select超时处理
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);//这时传入超时时间
} while (ret < 0 && errno == EINTR/** 如果是中断信号,则忽略 **/);
if (ret == 0)
{//表示已经超时
ret = -1;
errno = ETIMEDOUT;
}
else if (ret == 1)//表示没有超时,成功产生了可读事件
ret = 0;
}
return ret;
}
【说明】:对于这个工具方法,重在理解是如何封装的,不一定要自己完全写,之后可以直接拿过来用。
write_timeout函数封装:
当理解了read_timeout函数的实现,对于写函数的实现就不难了,下面直接贴出来,基本类似,就不多说了:
/**
* write_timeout - 读超时检测函数,不含写操作
* @fd: 文件描述符
* @wait_seconds: 等待超时秒数,如果为0表示不检测超时
* 成功(未超时)返回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, NULL, &write_fdset, &timeout);
} while (ret < 0 && errno == EINTR);
if (ret == 0)
{
ret = -1;
errno = ETIMEDOUT;
}
else if (ret == 1)
ret = 0;
}
return ret;
}
accept_timeout函数封装:
关于这个函数的封装也不是太难理解,下面也以注释的方式贴出来:
/**
* accept_timeout - 带超时的accept
* @fd: 套接字
* @addr: 输出参数,返回对方地址
* @wait_seconds: 等待超时秒数,如果为0表示正常模式
* 成功(未超时)返回已连接套接字,超时返回-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)
{//如果超时时间大于0才进行select超时处理,否则不检测超时,直接调用accept
fd_set accept_fdset;//定义一个集合
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);
if (ret == -1)//代表select失败了
return -1;
else if (ret == 0)
{//超时了
errno = ETIMEDOUT;
return -1;
}
}
//如果走到这里,证明检测到了事件,则需要对其进行处理;或者是超时时间没有设置也会走到这
if (addr != NULL)//有地址的accept,这时不再阻塞
ret = accept(fd, (struct sockaddr*)addr, &addrlen);//此时返回连接套接字
else//无地址的accept
ret = accept(fd, NULL, NULL);
if (ret == -1)//表示accept失败
ERR_EXIT("accept");
return ret;
}
connect_timeout函数封装:这个函数最难~
首先先明白一点,为啥要设置连接超时呢?这里需要从连接建立的三次握手说起,如下图:
![](https://i-blog.csdnimg.cn/blog_migrate/cb3700a23303179d3fac664fa195f9fc.png)
下面来看下具体函数的实现,相比前几个,这个要复杂一些,因为不能够直接调用connect(),一旦调用了它,就意味着阻塞了,所以说希望不能阻塞的方式调用,所以需要将文件描述符设置为非阻塞模式,这里封装成了一个方法,如下:
/**
* activate_noblock - 设置I/O为非阻塞模式
* @fd: 文件描符符
*/
void activate_nonblock(int fd)
{
int ret;
int flags = fcntl(fd, F_GETFL);//获得原来的模式
if (flags == -1)
ERR_EXIT("fcntl");
flags |= O_NONBLOCK;//设置非阻塞模式
ret = fcntl(fd, F_SETFL, flags);
if (ret == -1)
ERR_EXIT("fcntl");
}
另外,还配对一个清除非阻塞模式的方法:
/**
* deactivate_nonblock - 设置I/O为阻塞模式
* @fd: 文件描符符
*/
void deactivate_nonblock(int fd)
{
int ret;
int flags = fcntl(fd, F_GETFL);
if (flags == -1)
ERR_EXIT("fcntl");
flags &= ~O_NONBLOCK;
ret = fcntl(fd, F_SETFL, flags);
if (ret == -1)
ERR_EXIT("fcntl");
}
【说明】:关于上面两个函数的实现,可以参考之前学习的fcntl函数。
/**
* connect_timeout - connect
* @fd: 套接字
* @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);//设置套接字为非阻塞模式
ret = connect(fd, (struct sockaddr*)addr, addrlen);
if (ret < 0 && errno == EINPROGRESS)
{//连接正在处理,这时应该用select检测连接的超时
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
{
/* 一量连接建立,套接字就可写,这里是将关心写的事件 */
ret = select(fd + 1, NULL, &connect_fdset, NULL, &timeout);
} while (ret < 0 && errno == EINTR);
if (ret == 0)
{//表示连接超时了
ret = -1;
errno = ETIMEDOUT;
}
else if (ret < 0)//连接失败了
return -1;
else if (ret == 1)
{//这时检测到有可写事件了
/* ret返回为1,可能有两种情况,一种是连接建立成功,一种是套接字产生错误,*/
/* 此时错误信息不会保存至errno变量中,因此,需要调用getsockopt来获取。 */
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)
{//连接建立成功
ret = 0;
}
else
{//套接字产生错误
errno = err;
ret = -1;
}
}
}
if (wait_seconds > 0)
{
deactivate_nonblock(fd);//还原套接字为阻塞模式
}
return ret;
}
下面用程序来使用一下上面的超时函数,还是用回射服务端/客户程序,但是不是用之前的,而是用一个最简单的,重在测试:
srv.c:
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#define ERR_EXIT(m) \
do \
{ \
perror(m); \
exit(EXIT_FAILURE); \
} while(0)
int main(void)
{
int listenfd;
if ((listenfd = socket(PF_INET, SOCK_STREAM, 0)) < 0)
ERR_EXIT("socket");
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");
if (bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
ERR_EXIT("bind");
if (listen(listenfd, SOMAXCONN) < 0)
ERR_EXIT("listen");
struct sockaddr_in peeraddr;
socklen_t peerlen;
int conn;
if ((conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen)) < 0)
ERR_EXIT("accept");
printf("ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
return 0;
}
cli.c:
#include "sysutil.h"
int main(void)
{
int sock;
if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
ERR_EXIT("socket");
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);//设置超时为5秒
if (ret == -1 && errno == ETIMEDOUT)
{
printf("timeout...\n");
return 1;
}
else if (ret == -1)
ERR_EXIT("connect_timeout");
struct sockaddr_in localaddr;
socklen_t addrlen = sizeof(localaddr);
if (getsockname(sock, (struct sockaddr*)&localaddr, &addrlen) < 0)
ERR_EXIT("getsockname");
printf("ip=%s port=%d\n", inet_ntoa(localaddr.sin_addr), ntohs(localaddr.sin_port));
return 0;
}
为了看清楚connect_timeout内部执行的流程是怎么样,可以在其内部打印一些日志就知道了,加入日志如下:
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);//设置套接字为非阻塞模式
ret = connect(fd, (struct sockaddr*)addr, addrlen);
if (ret < 0 && errno == EINPROGRESS)
{//连接正在处理,这时应该用select检测连接的超时
printf("AAAAA\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
{
/* 一量连接建立,套接字就可写,这里是将关心写的事件 */
ret = select(fd + 1, NULL, &connect_fdset, NULL, &timeout);
} while (ret < 0 && errno == EINTR);
if (ret == 0)
{//表示连接超时了
ret = -1;
errno = ETIMEDOUT;
}
else if (ret < 0)//连接失败了
return -1;
else if (ret == 1)
{//这时检测到有可写事件了
printf("BBBBB\n");
/* ret返回为1,可能有两种情况,一种是连接建立成功,一种是套接字产生错误,*/
/* 此时错误信息不会保存至errno变量中,因此,需要调用getsockopt来获取。 */
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("CCCCCC\n");
ret = 0;
}
else
{//套接字产生错误
printf("DDDDDDD\n");
errno = err;
ret = -1;
}
}
}
if (wait_seconds > 0)
{
deactivate_nonblock(fd);//还原套接字为阻塞模式
}
return ret;
}
编译运行:
![](https://i-blog.csdnimg.cn/blog_migrate/afb32b4706c8975fad4f6b74fca94286.png)
由于connect本地模拟不了超时效果,因为没有网络拥塞的情况,下面可以演示一个错误,就是在服务端没有运行时,直接运行客户端,如下:
![](https://i-blog.csdnimg.cn/blog_migrate/5af58786bb423c7ce8d0d45cfec502d4.png)
这是在客户端这一段代码报出来的:
![](https://i-blog.csdnimg.cn/blog_migrate/b8509b51f3676f41638f9d75a2715cd7.png)
由于数据比较少,虽说已经封装好了超时的函数,但是不好演示网络拥塞导致的超时,不过,重在理解代码,好了,下节继续~