linux网络编程之socket编程(十一)

今天继续学习socket编程，这次主要是学习超时方法的封装，内容如下：

①、alarm【不常用，了解既可】

它的实现思路是这样的：

但是这种方案有一定的问题，因为闹钟可能会作为其它的用途，这时所设置的闹钟跟其它用途的闹钟会产生冲突，而这些冲突的解决，会比较麻烦，这里就不多讨论了，因为不使用它，仅了解既可，是不会用闹钟的方式来实现超时的。

②、套接字选项【不常用，了解既可】

          SO_SNDTIMEO：发送的超时时间

          SO_RCVTIMEO：接收的超时时间

具体实现思路是这样的：

但是，也不会用这种方式，因为存在移植兼容的问题。

③、select【常用，这次学习的重点】

read_timeout函数封装:

下面会仔细分析是如何封装的，在封装之后，先看下函数原形：

所以，先不关心它是如何实现的，依照这个函数原形，其使用方法如下【伪代码】：

另外，如果想按照正常的方式来处理，可以将超时参数传0既可，如下：

下面将整个函数的实现贴出来，比较容易理解，这里就不一一赘述了，里面的注释比较详细:

/**
 * read_timeout - 读超时检测函数，不含读操作
 * @fd: 文件描述符
 * @wait_seconds: 等待超时秒数，如果为0表示不检测超时
 * 成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT
 */
int read_timeout(int fd, unsigned int wait_seconds)
{
    int ret = ;//默认返回值为0，也就是未超时
    if (wait_seconds > )
    {//如果当传过来的超时时间大于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 = ;//不关心微秒
        do
        {
            ret = select(fd + , &read_fdset, NULL, NULL, &timeout);//这时传入超时时间
        } while (ret <  && errno == EINTR/** 如果是中断信号，则忽略 **/);

        if (ret == )
        {//表示已经超时
            ret = -;
            errno = ETIMEDOUT;
        }
        else if (ret == )//表示没有超时，成功产生了可读事件
            ret = ;
    }

    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 = ;
    if (wait_seconds > )
    {
        fd_set write_fdset;//只是这时变成了写的集合
        struct timeval timeout;

        FD_ZERO(&write_fdset);
        FD_SET(fd, &write_fdset);//将入到写集合中

        timeout.tv_sec = wait_seconds;
        timeout.tv_usec = ;
        do
        {
            ret = select(fd + , NULL, NULL, &write_fdset, &timeout);
        } while (ret <  && errno == EINTR);

        if (ret == )
        {
            ret = -;
            errno = ETIMEDOUT;
        }
        else if (ret == )
            ret = ;
    }

    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才进行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 = ;
        do
        {
            ret = select(fd + , &accept_fdset, NULL, NULL, &timeout);
        } while (ret <  && errno == EINTR);
        if (ret == -)//代表select失败了
            return -;
        else if (ret == )
        {//超时了
            errno = ETIMEDOUT;
            return -;
        }
    }

    //如果走到这里，证明检测到了事件，则需要对其进行处理；或者是超时时间没有设置也会走到这
    if (addr != NULL)//有地址的accept，这时不再阻塞
        ret = accept(fd, (struct sockaddr*)addr, &addrlen);//此时返回连接套接字
    else//无地址的accept
        ret = accept(fd, NULL, NULL);
    if (ret == -)//表示accept失败
        ERR_EXIT("accept");

    return ret;
}

connect_timeout函数封装:这个函数最难~

首先先明白一点，为啥要设置连接超时呢？这里需要从连接建立的三次握手说起，如下图：

下面来看下具体函数的实现，相比前几个，这个要复杂一些，因为不能够直接调用connect()，一旦调用了它，就意味着阻塞了，所以说希望不能阻塞的方式调用，所以需要将文件描述符设置为非阻塞模式，这里封装成了一个方法，如下：

/**
 * activate_noblock - 设置I/O为非阻塞模式
 * @fd: 文件描符符
 */
void activate_nonblock(int fd)
{
    int ret;
    int flags = fcntl(fd, F_GETFL);//获得原来的模式
    if (flags == -)
        ERR_EXIT("fcntl");

    flags |= O_NONBLOCK;//设置非阻塞模式
    ret = fcntl(fd, F_SETFL, flags);
    if (ret == -)
        ERR_EXIT("fcntl");
}

另外，还配对一个清除非阻塞模式的方法：

/**
 * deactivate_nonblock - 设置I/O为阻塞模式
 * @fd: 文件描符符
 */
void deactivate_nonblock(int fd)
{
    int ret;
    int flags = fcntl(fd, F_GETFL);
    if (flags == -)
        ERR_EXIT("fcntl");

    flags &= ~O_NONBLOCK;
    ret = fcntl(fd, F_SETFL, flags);
    if (ret == -)
        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 > )
        activate_nonblock(fd);//设置套接字为非阻塞模式

    ret = connect(fd, (struct sockaddr*)addr, addrlen);
    if (ret <  && 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 = ;
        do
        {
            /* 一量连接建立，套接字就可写，这里是将关心写的事件 */
            ret = select(fd + , NULL, &connect_fdset, NULL, &timeout);
        } while (ret <  && errno == EINTR);
        if (ret == )
        {//表示连接超时了
            ret = -;
            errno = ETIMEDOUT;
        }
        else if (ret < )//连接失败了
            return -;
        else if (ret == )
        {//这时检测到有可写事件了
            /* ret返回为1，可能有两种情况，一种是连接建立成功，一种是套接字产生错误，*/
            /* 此时错误信息不会保存至errno变量中，因此，需要调用getsockopt来获取。 */
            int err;
            socklen_t socklen = sizeof(err);
            int sockoptret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &socklen);//获取套接字的错误
            if (sockoptret == -)
            {//表示获取套接字错误
                return -;
            }
            if (err == )
            {//连接建立成功
                ret = ;
            }
            else
            {//套接字产生错误
                errno = err;
                ret = -;
            }
        }
    }
    if (wait_seconds > )
    {
        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()

int main(void)
{
    int listenfd;
    if ((listenfd = socket(PF_INET, SOCK_STREAM, )) < )
        ERR_EXIT("socket");

    struct sockaddr_in servaddr;
    memset(&servaddr, , sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons();
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    int on = ;
    if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < )
        ERR_EXIT("setsockopt");

    if (bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < )
        ERR_EXIT("bind");
    if (listen(listenfd, SOMAXCONN) < )
        ERR_EXIT("listen");

    struct sockaddr_in peeraddr;
    socklen_t peerlen;
    int conn;

    if ((conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen)) < )
        ERR_EXIT("accept");

    printf("ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));

    return ;
}

cli.c:

#include "sysutil.h"

int main(void)
{
    int sock;
    if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < )
        ERR_EXIT("socket");

    struct sockaddr_in servaddr;
    memset(&servaddr, , sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons();
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    int ret = connect_timeout(sock, &servaddr, 5);//设置超时为5秒
    if (ret == - && errno == ETIMEDOUT)
    {
        printf("timeout...\n");
        return ;
    }
    else if (ret == -)
        ERR_EXIT("connect_timeout");

    struct sockaddr_in localaddr;
    socklen_t addrlen = sizeof(localaddr);
    if (getsockname(sock, (struct sockaddr*)&localaddr, &addrlen) < )
        ERR_EXIT("getsockname");

    printf("ip=%s port=%d\n", inet_ntoa(localaddr.sin_addr), ntohs(localaddr.sin_port));

    return ;
}

为了看清楚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 > )
        activate_nonblock(fd);//设置套接字为非阻塞模式

    ret = connect(fd, (struct sockaddr*)addr, addrlen);
    if (ret <  && 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 = ;
        do
        {
            /* 一量连接建立，套接字就可写，这里是将关心写的事件 */
            ret = select(fd + , NULL, &connect_fdset, NULL, &timeout);
        } while (ret <  && errno == EINTR);
        if (ret == )
        {//表示连接超时了
            ret = -;
            errno = ETIMEDOUT;
        }
        else if (ret < )//连接失败了
            return -;
        else if (ret == )
        {//这时检测到有可写事件了
            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 == -)
            {//表示获取套接字错误
                return -;
            }
            if (err == )
            {//连接建立成功
                printf("CCCCCC\n");
                ret = ;
            }
            else
            {//套接字产生错误
                printf("DDDDDDD\n");
                errno = err;
                ret = -;
            }
        }
    }
    if (wait_seconds > )
    {
        deactivate_nonblock(fd);//还原套接字为阻塞模式
    }
    return ret;
}

编译运行：

由于connect本地模拟不了超时效果，因为没有网络拥塞的情况，下面可以演示一个错误，就是在服务端没有运行时，直接运行客户端，如下：

这是在客户端这一段代码报出来的：

由于数据比较少，虽说已经封装好了超时的函数，但是不好演示网络拥塞导致的超时，不过，重在理解代码，好了，下节继续~