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

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

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

巴特西

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

最新文章

热门文章