网络编程中的select实现超时检测和通用API

最新推荐文章于 2024-09-12 23:05:12 发布
最新推荐文章于 2024-09-12 23:05:12 发布
阅读量2.5k 收藏 7
点赞数 1
分类专栏： Linux应用编程 文章标签： 网络编程 select
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzjsqn/article/details/53790483
版权

关于select的基础知识在上一篇文章已经初步总结了，他的应用主要分为三个方向：

  1. 用于完成超时检测（connect、accept、read以及write）
  2. 用于处理客户端的普通文件描述符和套接字文件描述符，监控这些描述符可以避免在服务器死掉以后，客户端阻塞在等待标准输入或者其他文件的读取。
  3. 用于服务器构造多并发，使用select可以实现单进程实现多并发！只不过是自己管理所有建立的用于通信的链接和用于监听的套接字，有别于poll和epoll（底层自己管理）

实现connect超时检测

首先要明确以下知识点：

  • 在建立套接字（fd）以后默认是阻塞的
  • 如果客户端连接服务器发生异常，则默认阻塞的情况下，返回时间是1.5RTT，大约100秒！–软件质量低下
  • 先把套接字通过fcntl变为非阻塞模型，再调用connect函数
    • 如果网络顺利，直接建立链接
    • 如果网络不好，则根据返回值判断，connect的返回值如果是-1而且errno==EINPROGRESS表示客户端和服务器正在建立连接，需要等待一段时间才能建立链接
    • 等待的时间我们可以自己设定
    • 利用select监控该套接字—提高软件质量
  • 尽管select返回了套接字的可写状态（套接字默认是可写入状态，正常建立连接以后也是表返回可写入状态）但不一定表示就是正确建立链接
    • select返回大于零的值
    • 真正建立链接
    • 建立套接字产生错误，会返回写失败信息，造成可写入的状态。 此时错误信息不会保存至errno变量中，因此，需要调用getsockopt来获取。

/**
 * activate_noblock - 设置I/O为非阻塞模式
 * @fd: 文件描符符
 */
int activate_nonblock(int fd)
{
  int ret = 0;

  int flags = fcntl(fd,F_GETFL);
  if(-1 == flags)
  {
    ret =flags;
    perror("fcntl");
    return ret;
  }

  flags |= O_NONBLOCK;

  ret = fcntl(fd,F_SETFL,flags);
  if(ret == -1)
  {
    perror("fcntl(fd,F_SETFL,flags)");
    return ret;
  }

  return ret;
}

/**
 * deactivate_nonblock - 设置I/O为阻塞模式
 * @fd: 文件描符符
 */
int deactivate_nonblock(int fd)
{
  int ret = 0;

  int flags = fcntl(fd,F_GETFL);
  if(-1 == flags)
  {
    ret =flags;
    perror("fcntl");
    return ret;
  }

  flags &= ~O_NONBLOCK;

  ret = fcntl(fd,F_SETFL,flags);
  if(ret == -1)
  {
    perror("fcntl(fd,F_SETFL,flags)");
    return ret;
  }

  return ret;
}

/**
 * connect_timeout - connect
 * @fd: 套接字
 * @addr: 要连接的对方地址
 * @wait_seconds: 等待超时秒数，如果为0表示正常模式
 * 成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT
 */
static int connect_timeout(int fd, struct sockaddr_in *addr, unsigned int wait_seconds)
{
  int ret = 0;
  socklen_t addrlen = sizeof(struct sockaddr_in);
  fd_set connect_fdset;
  struct timeval timeout;

  int err;
    socklen_t socklen = sizeof(err);
    int sockoptret; 

  if(wait_seconds > 0)//设置成非阻塞--因为文件描述符默认是阻塞的
  {
    activate_nonblock(fd);
  }


  /*非阻塞
  --成功：立马建立连接
  --失败：ret < 0 && errno == EINPROGRESS，表示没有获取到链接
  */
  ret = connect(fd,(struct sockaddr*)addr,addrlen);
  if(ret < 0 && errno == EINPROGRESS)
  {
    FD_ZERO(&connect_fdset);
    FD_SET(fd,&connect_fdset);

    timeout.tv_sec = wait_seconds;
    timeout.tv_usec = 0;

    do
    {
      // 一但连接建立，则套接字就可写  所以connect_fdset放在了写集合中
      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)//select出错
    {
      return -1;
    }
    else if( ret == 1)//有两种情况会导致文件描述符变为可写入的状态/准备好的状态
    {
      /* ret返回为1（表示套接字可写），可能有两种情况，一种是连接建立成功，一种是套接字产生错误，*/
            /* 此时错误信息不会保存至errno变量中，因此，需要调用getsockopt来获取。 */
      sockoptret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &socklen);//获取套接字的状态
      if(sockoptret == -1)//getsockopt（可以修改十一种状态，诸如TIME_WAIT的时间等）调用失败
      {
        return -1;
      }
      if(err == 0)//真正可写入/准备好
        ret = 0;
      else{//-1表示套接字产生错误
        errno = err;
        ret = -1;
      }
    }
  }

  if (wait_seconds > 0)
    {
        deactivate_nonblock(fd);
    }

  return ret;
}

实现accept超时检测

/**
 * 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)
    {
        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)
            return -1;
        else if (ret == 0)
        {
            errno = ETIMEDOUT;
            return -1;
        }
    }

实现read超时检测

/**
 * 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)
    {
        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;

        //select返回值三态
        //1 若timeout时间到（超时），没有检测到读事件 ret返回=0
        //2 若ret返回<0 &&  errno == EINTR 说明select的过程中被别的信号中断（可中断睡眠原理）
        //2-1 若返回-1，select出错
        //3 若ret返回值>0 表示有read事件发生，返回事件发生的个数

        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超时检测

/**
 * 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, &write_fdset, NULL, &timeout);
        } while (ret < 0 && errno == EINTR);

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

    return ret;
}

利用select实现的通用套接字编程库

  • 头文件
#ifndef __COMSOCKET_H__
#define __COMSOCKET_H__

#ifdef __cplusplus

extern "C"
{
#endif


#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <errno.h>
#include <fcntl.h>

//错误码定义  

#define Sck_Ok              0
#define Sck_BaseErr         3000

#define Sck_ErrParam                    (Sck_BaseErr+1)
#define Sck_ErrTimeOut                  (Sck_BaseErr+2)
#define Sck_ErrPeerClosed               (Sck_BaseErr+3)
#define Sck_ErrMalloc                   (Sck_BaseErr+4)

//函数声明

//客户端环境低级初始化
int sckClient_init01(void **handle,char * ip,int port,int con_time,int send_time,int recv_time);


//客户端环境高级初始化
int sckClient_init(void **handle,int con_time,int send_time,int recv_time,int cnt);

//客户端获取链接
int sckClient_getConn(void *handle,char * ip,int port,int * con_fd);


//客户端关闭连接
int sckClient_closeConn(int  con_fd);

//客户端发送报文
int sckClient_send(void *handle, int con_fd,unsigned char *data, int datalen);

//客户端端接受报文
int sckClient_rcv(void *handle,int con_fd, unsigned char *out, int *outlen); //1


// 客户端环境释放 
void sckClient_destroy(void **handle);
/*=========================================================================================*/

//函数声明
//服务器端初始化
int sckServer_init(int port, int *listenfd);

int sckServer_accept(int listenfd, int *con_fd,  int timeout);
//服务器端发送报文
int sckServer_send(int con_fd,  unsigned char *data, int datalen, int timeout);
//服务器端端接受报文
int sckServer_rcv(int  con_fd, unsigned char *out, int *outlen,  int timeout); 

//服务器端环境释放 
int sckServer_destroy(int con_fd);

#ifdef __cplusplus
}
#endif
#endif
  • 实现文件

#include "comsocket.h"

typedef struct _sckHandle
{
  int sock_fd;
  int arrayNum;
  int con_time;
  int send_time;
  int recv_time;
}SckHandle;


/**
 * readn - 读取固定字节数
 * @fd: 文件描述符
 * @buf: 接收缓冲区
 * @count: 要读取的字节数
 * 成功返回count，失败返回-1，读到EOF返回<count
 */
ssize_t readn(int fd, void *buf, size_t count)
{
    size_t nleft = count;//剩余字节数
    ssize_t nread;//已经读取的字节数
    char *bufp = (char*)buf;

    while (nleft > 0)
    {
        if ((nread = read(fd, bufp, nleft)) < 0)
        {
            if (errno == EINTR)
                continue;
            return -1;
        }
        else if (nread == 0)
            return count - nleft;

        bufp += nread;
        nleft -= nread;
    }

    return count;
}

/**
 * writen - 发送固定字节数
 * @fd: 文件描述符
 * @buf: 发送缓冲区
 * @count: 要读取的字节数
 * 成功返回count，失败返回-1
 */
ssize_t writen(int fd, const void *buf, size_t count)
{
    size_t nleft = count;
    ssize_t nwritten;
    char *bufp = (char*)buf;

    while (nleft > 0)
    {
        if ((nwritten = write(fd, bufp, nleft)) < 0)
        {
            if (errno == EINTR)
                continue;
            return -1;
        }
        else if (nwritten == 0)
            continue;

        bufp += nwritten;
        nleft -= nwritten;
    }

    return count;
}

/**
 * recv_peek - 仅仅查看套接字缓冲区数据，但不移除数据
 * @sockfd: 套接字
 * @buf: 接收缓冲区
 * @len: 长度
 * 成功返回>=0，失败返回-1
 */
ssize_t recv_peek(int sockfd, void *buf, size_t len)
{
    while (1)
    {
        int ret = recv(sockfd, buf, len, MSG_PEEK);
        if (ret == -1 && errno == EINTR)
            continue;
        return ret;
    }
}

/**
 * activate_noblock - 设置I/O为非阻塞模式
 * @fd: 文件描符符
 */
int activate_nonblock(int fd)
{
  int ret = 0;

  int flags = fcntl(fd,F_GETFL);
  if(-1 == flags)
  {
    ret =flags;
    perror("fcntl");
    return ret;
  }

  flags |= O_NONBLOCK;

  ret = fcntl(fd,F_SETFL,flags);
  if(ret == -1)
  {
    perror("fcntl(fd,F_SETFL,flags)");
    return ret;
  }

  return ret;
}

/**
 * deactivate_nonblock - 设置I/O为阻塞模式
 * @fd: 文件描符符
 */
int deactivate_nonblock(int fd)
{
  int ret = 0;

  int flags = fcntl(fd,F_GETFL);
  if(-1 == flags)
  {
    ret =flags;
    perror("fcntl");
    return ret;
  }

  flags &= ~O_NONBLOCK;

  ret = fcntl(fd,F_SETFL,flags);
  if(ret == -1)
  {
    perror("fcntl(fd,F_SETFL,flags)");
    return ret;
  }

  return ret;
}



/**
 * connect_timeout - connect
 * @fd: 套接字
 * @addr: 要连接的对方地址
 * @wait_seconds: 等待超时秒数，如果为0表示正常模式
 * 成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT
 */
static int connect_timeout(int fd, struct sockaddr_in *addr, unsigned int wait_seconds)
{
  int ret = 0;
  socklen_t addrlen = sizeof(struct sockaddr_in);
  fd_set connect_fdset;
  struct timeval timeout;

  int err;
    socklen_t socklen = sizeof(err);
    int sockoptret; 

  if(wait_seconds > 0)//设置成非阻塞--因为文件描述符默认是阻塞的
  {
    activate_nonblock(fd);
  }


  /*非阻塞
  --成功：立马建立连接
  --失败：ret < 0 && errno == EINPROGRESS，表示没有获取到链接
  */
  ret = connect(fd,(struct sockaddr*)addr,addrlen);
  if(ret < 0 && errno == EINPROGRESS)
  {
    FD_ZERO(&connect_fdset);
    FD_SET(fd,&connect_fdset);

    timeout.tv_sec = wait_seconds;
    timeout.tv_usec = 0;

    do
    {
      // 一但连接建立，则套接字就可写  所以connect_fdset放在了写集合中
      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)//select出错
    {
      return -1;
    }
    else if( ret == 1)//有两种情况会导致文件描述符变为可写入的状态/准备好的状态
    {
      /* ret返回为1（表示套接字可写），可能有两种情况，一种是连接建立成功，一种是套接字产生错误，*/
            /* 此时错误信息不会保存至errno变量中，因此，需要调用getsockopt来获取。 */
      sockoptret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &socklen);//获取套接字的状态
      if(sockoptret == -1)//getsockopt（可以修改十一种状态，诸如TIME_WAIT的时间等）调用失败
      {
        return -1;
      }
      if(err == 0)//真正可写入/准备好
        ret = 0;
      else{//-1表示套接字产生错误
        errno = err;
        ret = -1;
      }
    }
  }

  if (wait_seconds > 0)
    {
        deactivate_nonblock(fd);
    }

  return ret;
}


/**
 * 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, &write_fdset, NULL, &timeout);
        } while (ret < 0 && errno == EINTR);

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

    return ret;
}


/**
 * 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)
    {
        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;

        //select返回值三态
        //1 若timeout时间到（超时），没有检测到读事件 ret返回=0
        //2 若ret返回<0 &&  errno == EINTR 说明select的过程中被别的信号中断（可中断睡眠原理）
        //2-1 若返回-1，select出错
        //3 若ret返回值>0 表示有read事件发生，返回事件发生的个数

        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;
}


//客户端环境低级初始化
int sckClient_init01(void **handle,char * ip,int port,int con_time,int send_time,int recv_time)
{
  int ret = 0;
  SckHandle * tmp = NULL;
  int sock;
  int con;
  struct sockaddr_in serv_addr;

  if(handle == NULL || con_time < 0 || send_time < 0 || recv_time < 0
    || ip == NULL|| port < 0||port > 65535)
  {
    ret = Sck_ErrParam;
    perror("sckClient_init:(handle == NULL || con_time < 0 || send_time < 0 || recv_time < 0)");
    return ret;
  }


  tmp = (SckHandle *)malloc(sizeof(SckHandle));
  if(tmp == NULL)
  {
    ret =  Sck_ErrMalloc;
    perror("malloc(sizeof(SckHandle)");
    return ret;
  }

  tmp->con_time = con_time;
  tmp->send_time = send_time;
  tmp->recv_time = recv_time;

  sock = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
  if(sock < 0)
  {
    ret = errno;
    perror("socket");
    return ret;
  }

  bzero(&serv_addr,sizeof(serv_addr));
  serv_addr.sin_family = AF_INET;
  serv_addr.sin_port = htons(port);
  serv_addr.sin_addr.s_addr = inet_addr(ip);

  if((con = connect(sock,(struct sockaddr*)&serv_addr,sizeof(serv_addr))) < 0)
  {
    ret = errno;
    perror("connect");
    return ret;
  }
  //tmp->con_fd = con;
  tmp->sock_fd = sock;

  *handle = tmp;

  return ret;
}

//客户端环境高级初始化
//成功返回0，失败返回相应的错误码
//参数分别是SckHandle的结构体成员
int sckClient_init(void **handle,int con_time,int send_time,int recv_time,int cnt)
{
  int ret = 0;
  SckHandle * tmp = NULL;

  if(handle == NULL || con_time < 0 || send_time < 0 || recv_time < 0)//合法性检测
  {
    ret = Sck_ErrParam;
    printf("sckClient_init:(handle == NULL || con_time < 0 || send_time < 0 || recv_time < 0)");
    return ret;
  }

  /*分配堆空间内存--临时变量*/
  tmp = (SckHandle *)malloc(sizeof(SckHandle));
  if(tmp == NULL)
  {
    ret =  Sck_ErrMalloc;
    perror("malloc(sizeof(SckHandle)");
    return ret;
  }

  //进行初始化
  tmp->con_time = con_time;
  tmp->send_time = send_time;
  tmp->recv_time = recv_time;
  tmp->arrayNum = cnt;

  //将分配好的结果甩出去
  *handle = tmp;

  return ret;
}


//客户端获取链接
//成功：返回0，失败返回错误代码
//参数是服务器地址以及已经初始化好的句柄和准备建立的套接字
int sckClient_getConn(void *handle,char * ip,int port,int * con_fd)
{
  int ret = 0;
  struct sockaddr_in serv_addr;
  SckHandle * tmp = (SckHandle *)handle;
  int sock;

  //合法性检测
  if(handle == NULL || ip == NULL || con_fd == NULL 
    || port < 0 || port  > 65535)
    {
      ret = Sck_ErrParam;
      printf("sckClient_getConn(handle == NULL || ip == NULL || con_fd == NULL port < 0 || port  > 65535)\n");
      return ret;
    }

  //建立套接字
  sock = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
  if(sock < 0)
  {
    ret = errno;
    perror("socket");
    return ret;
  }

  //将建立好的套接字赋值给临时变量
  tmp->sock_fd = sock;

  //设置要连接的服务器地址
  bzero(&serv_addr,sizeof(serv_addr));
  serv_addr.sin_family = AF_INET;
  serv_addr.sin_port = htons(port);
  serv_addr.sin_addr.s_addr = inet_addr(ip);

  /*if(connect(tmp->sock_fd,(struct sockaddr*)&serv_addr,sizeof(serv_addr)) < 0)
  {
    ret = errno;
    perror("connect");
    return ret;
  }*/

  //连接服务器
  // 成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT
  ret = connect_timeout(tmp->sock_fd, (struct sockaddr_in*) (&serv_addr), (unsigned int )tmp->con_time);
  if (ret < 0)//连接服务器失败
  {
    if (ret==-1 && errno == ETIMEDOUT)//连接超时
    {
        ret = Sck_ErrTimeOut;
        return ret;
    }
    else//其他情况的连接失败
    {
        printf("func connect_timeout() err:  %d\n", ret);
    }
  }
  *con_fd = tmp->sock_fd;  //将建立好的套接字甩出去
  return ret;
}


//客户端关闭连接
//参数：要关闭的套接字
int sckClient_closeConn(int  con_fd)
{
  if(con_fd > 0)
  {
    close(con_fd);
  }
  return 0;
}

//客户端发送报文
//成功：返回0，失败：返回错误代码（-1或者其他非零值）
//参数：句柄、已经建立的套接字、要发送数据缓冲区的地址、要发送的数据长度
int sckClient_send(void *handle, int con_fd,unsigned char *data, int datalen)
{
  int ret = 0;
  SckHandle * tmp = (SckHandle *)handle;
  unsigned char * pkt = NULL;

  int nwrite = 0;
  int pkt_len = 0;

  //合法性检测
  if(handle == NULL || data == NULL
    || con_fd < 0 || con_fd > 65535 || datalen <0)
    {
      ret = Sck_ErrParam;
      perror("Sck_ErrParam");
      return ret;
    }

  //写超时检测
  // 成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT
  ret = write_timeout(con_fd,tmp->send_time);

  if(ret == 0)//没有超时
  {
    pkt = (unsigned char *)malloc(datalen + sizeof(int));//分配堆空间内存--临时数据包
    if(pkt == NULL)
    {
      ret = Sck_ErrMalloc;
      perror("malloc(datalen + sizeof(int))");
      return ret;
    }

    pkt_len = htonl(datalen);//包头（数据包长度）字节序转换
    memcpy(pkt,&pkt_len,sizeof(int));//复制转换后表示长度的数据到包头
    memcpy(pkt+sizeof(int),data,datalen);//复制有效数据到包体

    nwrite = writen(con_fd,pkt,datalen + sizeof(int));//向服务器发送数据
    if(nwrite < (datalen + sizeof(int)))//写入出错
    {
      if(pkt != NULL)//回收内存
      {
        free(pkt);
        pkt = NULL;
      }
      return nwrite;
    }

  }
  else if(ret < 0)//在检测超时的时候调用select失败
  {
    if(ret == -1 && errno == ETIMEDOUT)//确实超时了
    {
      ret = Sck_ErrTimeOut;
      printf("write_timeout(con_fd,tmp->send_time)");
      return ret;
    } 
    return ret;//其他失败的情况
  }

  //内存回收
  free(pkt);
  pkt = NULL;
  return ret;
}

/*typedef struct _pkt
{
  int len;
  unsigned char buf[1024];
}pkt_t;
*/
//客户端端接受报文
//成功：返回0，失败：返回错误代码或者实际读取到的字节数，但是该数字小于包头存储的数字
//参数：句柄、已经建立好的套接字，目的缓冲区地址、正确读取以后读取到的字节数
int sckClient_rcv(void *handle,int con_fd, unsigned char *out, int *outlen)
{
  int ret = 0;
  SckHandle * tmp = (SckHandle *)handle;

  int tmp_len ;

  //合法性检测
  if(handle == NULL || out == NULL
    || outlen == NULL||con_fd < 0 || con_fd > 65535)
    {
      ret = Sck_ErrParam;
      perror("Sck_ErrParam");
      return ret;
    }


  //超时检测  
  ret = read_timeout(con_fd, tmp->recv_time);
  if(ret == -1)//调用select失败
  {
    if(errno == ETIMEDOUT)//确实超时了
    {
      ret = Sck_ErrTimeOut;
      perror("read_timeout");
      return ret;
    }
    perror("read_timeout");//其他情况的失败
    return ret;
  }
  else if(ret == 0)//没有超时
  {
    //成功返回count，失败返回-1，读到EOF返回<count
    ret = readn(con_fd,&tmp_len,sizeof(tmp_len));//读取包头--表示有效数据长度
    if(ret == -1)//读取失败 
    {
      printf("func readn() err:%d\n",ret);
      return ret;
    }
    else if(ret < sizeof(tmp_len))//读取结束--没有数据可读--对方关闭连接
    {
      ret = Sck_ErrPeerClosed;
      printf("client close\n");
      return ret ;//返回读取到的字节数--没用的字节数--表示错误
    }

    tmp_len = ntohl(tmp_len);//字节序转换得到包体长度
    ret = readn(con_fd,out,tmp_len);//读取指定长度的有效数据
    if(ret == -1)//读取失败
    {
      printf("func readn() err:%d\n",ret);
      return ret;
    }
    else if(ret < tmp_len)//对方关闭连接
    {
      ret = Sck_ErrPeerClosed;
      printf("client close\n");
      return ret ;//返回读取到的字节数--没用的字节数--表示错误
    }

  }

  *outlen = tmp_len;

  return 0;//最后一定要返回0，因为ret在最后变成了readn函数的返回结果--读取到的字节数
}

// 客户端环境释放 
//参数：句柄

void sckClient_destroy(void **handle)
{
  if(handle != NULL)
  {
    free(*handle);
    *handle = NULL;
  }
}

/*===================================================================================*/

//服务器端初始化
//成功：返回0，失败：返回错误码
//参数：要绑定的端口号、准备建立的监听套接字
int sckServer_init(int port, int *listenfd)
{
  int   ret = 0;
    int mylistenfd;
    struct sockaddr_in servaddr;

  //初始化服务器地址
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(port);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    //建立监听用的套接字 
    mylistenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (mylistenfd < 0)
    {
        ret = errno ;
        printf("func socket() err:%d \n", ret);
        return ret;
    }


  //设置地址复用
    int on = 1;
    ret = setsockopt(mylistenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on) );
    if (ret < 0)
    {
        ret = errno ;
        printf("func setsockopt() err:%d \n", ret);
        return ret;
    }


  //绑定地址/端口和监听用的套接字
    ret = bind(mylistenfd, (struct sockaddr*)&servaddr, sizeof(servaddr));
    if (ret < 0)
    {
        ret = errno ;
        printf("func bind() err:%d \n", ret);
        return ret;
    }

  //开始监听    
    ret = listen(mylistenfd, SOMAXCONN);
    if (ret < 0)
    {
        ret = errno ;
        printf("func listen() err:%d \n", ret);
        return ret;
    }

  //将建立好的监听套接字甩出去   
    *listenfd = mylistenfd;

    return ret;//成功初始化返回0，否则返回出错步骤返回的错误代码
}


/**
 * 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)
    {
        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)
            return -1;
        else if (ret == 0)
        {
            errno = ETIMEDOUT;
            return -1;
        }
   return ret ;
    }

    //一但检测出 有select事件发生，表示对等方完成了三次握手，客户端有新连接建立
    //此时再调用accept将不会堵塞
    if (addr != NULL)
        ret = accept(fd, (struct sockaddr*)addr, &addrlen); //返回已连接套接字
    else
        ret = accept(fd, NULL, NULL);
        if (ret == -1)
        {
            ret = errno;
            printf("func accept() err:%d \n", ret);
            return ret;
        }


    return ret;
}

//服务器端接受客户端连接请求
//成功：返回0，失败：返回错误码
//参数：已经建立好的用于监听的套接字，准备建立的用于连接的套接字文件描述符--连接、超时时间值
int sckServer_accept(int listenfd, int *con_fd,  int timeout)
{
  int   ret = 0;

  //超时检测
  //成功（未超时）返回已连接套接字，超时返回-1并且errno = ETIMEDOUT
    ret = accept_timeout(listenfd, NULL, (unsigned int) timeout);//这里可以改进--这里没有保存客户端的地址
    if (ret < 0)
    {
        if (ret == -1 && errno == ETIMEDOUT)//确实超时
        {
            ret = Sck_ErrTimeOut;
            printf("func accept_timeout() timeout err:%d \n", ret);
            return ret;
        }
        else//其他select失败的情况
        {
            ret = errno;
            printf("func accept_timeout() err:%d \n", ret);
            return ret;
        }
    }

    *con_fd = ret;//将从完成三次握手的队列里面取出可用的连接甩出去
    return ret;//成功返回0，失败返回错误代码
}

//服务器端发送报文
//成功：返回0，失败：返回错误代码或者实际写入的字节数
//参数：已经建立好的连接，待发送数据、要发送长度、超时时间
int sckServer_send(int con_fd,  unsigned char *data, int datalen, int timeout)
{
  int   ret = 0;
  int writed = 0;
  unsigned char *netdata = NULL;
  //超时检测
  // 成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT
    ret = write_timeout(con_fd, timeout);
    if (ret == 0)//没有超时
    {
        writed = 0;
        netdata = ( unsigned char *)malloc(datalen + 4);//分配空间
        if ( netdata == NULL)
        {
            ret = Sck_ErrMalloc;
            printf("func sckServer_send() mlloc Err:%d\n ", ret);
            return ret;
        }
    //数据打包
        int netlen = htonl(datalen);
        memcpy(netdata, &netlen, 4);
        memcpy(netdata+4, data, datalen);

    //数据发送
        writed = writen(con_fd, netdata, datalen + 4);
        if (writed < (datalen + 4) )//对方关闭
        {
            if (netdata != NULL) 
            {
                free(netdata);//内存回收
                netdata = NULL;
            }
            return writed;//返回实际写入的数据--非零都表示发送失败
        }

    }
    else if (ret < 0)
    {
        //失败返回-1，超时返回-1并且errno = ETIMEDOUT
        if (ret == -1 && errno == ETIMEDOUT)//确实超时
        {
            ret = Sck_ErrTimeOut;
            printf("func sckServer_send() mlloc Err:%d\n ", ret);
            return ret;
        }
        return ret;//其他情况的select失败。ret非零，但不一定是-1
    }


  free(netdata);//内存回收
    netdata = NULL;
    return ret;
}


//服务器端端接受报文
//成功：返回0，失败：返回错误代码或者实际读取到的字节数，但是该数字小于包头存储的数字
//参数：已经建立好的连接，目的缓冲区地址、正确读取以后读取到的字节数，超时时间
int sckServer_rcv(int  con_fd, unsigned char *out, int *outlen,  int timeout)
{
  int       ret = 0;

  //合法性检测
    if (out==NULL || outlen==NULL)
    {
        ret = Sck_ErrParam;
        printf("func sckClient_rev() timeout , err:%d \n", Sck_ErrTimeOut);
        return ret;
    }

    ret =  read_timeout(con_fd, timeout); //超时检测
    if (ret != 0)//select调用失败
    {
        if (ret==-1 || errno == ETIMEDOUT)//确实超时了
        {
            ret = Sck_ErrTimeOut;
            printf("func sckClient_rev() timeout , err:%d \n", Sck_ErrTimeOut);
            return ret;
        }
        else//其他情况的失败
        {
            printf("func sckClient_rev() timeout , err:%d \n", Sck_ErrTimeOut);
            return ret;
        }   
    }
    //没有超时
    int netdatalen = 0;
  ret = readn(con_fd, &netdatalen,  4); //读包头 4个字节
    if (ret == -1)//读取失败
    {
        printf("func readn() err:%d \n", ret);
        return ret;
    }
    else if (ret < 4)//对方关闭
    {
        ret = Sck_ErrPeerClosed;
        printf("func readn() err peer closed:%d \n", ret);
        return ret;
    }

    int n;
    n = ntohl(netdatalen);//字节序转换
    ret = readn(con_fd, out, n); //根据长度读数据
    if (ret == -1)//读取失败
    {
        printf("func readn() err:%d \n", ret);
        return ret;
    }
    else if (ret < n)//对方关闭
    {
        ret = Sck_ErrPeerClosed;
        printf("func readn() err peer closed:%d \n", ret);
        return ret;//返回读取到的字节数--没用的字节数--表示错误
    }


    *outlen = n;//将正确读取以后读取到的字节数甩出去

    return 0;//最后一定要返回0，因为ret在最后变成了readn函数的返回结果--读取到的实际字节数
}

//服务器端环境释放 
//成功：返回，失败：返回-1
//准备关闭的链接
int sckServer_destroy(int con_fd)
{
  if(close(con_fd) == 0)
    return 0;
  else 
    return -1;
}
  • 客户端测试代码


#include "comsocket.h"



int main()
{
  void * handle = NULL;
  int ret = 0;
  unsigned char *data = (unsigned char *)"asdfghjklaedas";
  unsigned char out[1024] = {0};
  int datalen = 10;
  int outlen = 1024;
  int con_fd;
  //客户端环境初始化
  ret = sckClient_init(&handle,5,5,5,1);

  ret = sckClient_getConn(handle,"192.168.1.110",8001,&con_fd);


  //客户端发送报文
  ret = sckClient_send(handle,con_fd, data,datalen);

  //客户端端接受报文
  ret = sckClient_rcv(handle,con_fd,out, &outlen); 
  out[outlen] = '\0';
    printf("data: %s \nlen: %d\n", out,outlen);

  // 客户端环境释放 
  sckClient_destroy(&handle);

  return ret;
}
  • 服务器端测试代码
#include "comsocket.h"

#define PORT 8001


void chld_handle(int sig)
{
  pid_t my_pid;
  //wait(NULL);//只能处理单进程的情况
  while((my_pid = waitpid(-1, NULL, WNOHANG)) > 0)
    printf("child is died,parent take care of it:%d\n", my_pid);

}
int main()
{
  int ret = 0;
  int listenfd;
  int con_fd;
  int datalen = 1024;
  int timeout = 5;
  //unsigned char *data = (unsigned char *)"lzjyrm";

  unsigned char recv[1024] = {0};


  pid_t pid;

  signal(SIGCHLD,chld_handle);
  signal(SIGPIPE,SIG_IGN);

  ret = sckServer_init(PORT, &listenfd);
  if(ret != 0)
  {
    printf("sckServer_init err:%d\n ",ret);
    return ret;
  }
  printf("Waiting for connect.....\n");
  while(1)
  {
    ret = sckServer_accept(listenfd, &con_fd,  timeout);
    if(ret == Sck_ErrTimeOut)
    {
      printf("sckServer_accept Sck_ErrTimeOut");
      continue;
    }

    pid = fork();

    if(pid == -1)
    {
      perror("fork");
      return errno;
    }
    else if(pid == 0)
    {
      close(listenfd);
      while(1)
      {
        memset(recv,0,sizeof(recv));
        ret = sckServer_rcv(con_fd, recv, &datalen,  timeout);  //服务器端端接受报文
        if(ret != 0)
        {
          printf("sckServer_rcv: %d\n",ret);
          break;
        }
        recv[datalen] = '\0';
        printf("rcv:%s\n==================\n",recv);
        //服务器端发送报文
        ret = sckServer_send(con_fd,recv, datalen, timeout);
        if(ret != 0)
        {
          printf("sckServer_send: %d\n",ret);
          break;
        }
      }
      close(con_fd);
      exit(ret);
    }
    else if(pid > 0)
    {
      close(con_fd);
    }
  }

  //服务器端环境释放 
  //ret = sckServer_destroy(void **handle);
  return 0;
}
小帅比simon
关注
专栏目录
Socket编程 | TCP编程基本流程和API详解-1
Jaylen.sun的嵌入式之旅
02-10 538
TCP (即传输控制协议) 是一种面向连接的传输层协议，它能提供高可靠性通信 (即数据无误、数据无丢失、数据无失序、数据无重复到达的通信)。
本文将以 Istio 为例，介绍如何利用声明式 API 来定义和管理服务网格
AI天才研究院
08-13 99
声明式 API 是一种描述集群 desired state 的 API，它可以让用户用更少的代码，更易于理解的方式来描述集群期望状态，而不是直接操作底层 Kubernetes 对象（比如 Pod、Service 和 Deployment）。这种 API 可以被用来配置自动化工具和流程，并且可以应用到任意 Kubernetes 上。声明式 API 的目标是通过提供简单、可读性高、方便扩展的语言模型来提升用户体验。
网络编程之超时检测
鹰击长空KO的博客
10-18 489
网络编程超时检测
SELECT超时小结
wangluozhangleilei的专栏
07-19 2144
目前各平台通用的设置socket connect超时的办法是通过select()，具体方法如下 1.建立socket； 2.将该socket设置为非阻塞模式； 3.调用connect()； 4.使用select()检查该socket描述符是否可写； 5.根据select()返回的结果判断connect()结果； 6.将socket设回阻塞模式。
day10（网络编程基础）setsockopt、超时检测
最新发布
QR70892的博客
09-12 486
使用 setsockopt 函数可以对套接字进行各种选项设置。在网络编程中，超时检测是很重要的一环，可以通过设置超时时间来避免程序在等待网络响应时无限期阻塞。setsockopt 函数可以用来设置套接字的超时选项，确保在规定时间内如果没有收到响应就采取相应的处理措施。
select超时
kejiazhw的专栏
06-06 5940
select 函数原型：        int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
网络编程select
白菜有罪的专栏
09-24 969
select模型实现了单线程上处理多个套接字的可能 1.select 函数定义如下 int select(      int nfds;        fd_set* readfds;   //指向一个套接字集合      fd_set* writefds;      fd_set* exceptfds;  //指向一个套接字集合，用来检查错误     const str
关于select函数超时时间问题
热门推荐
仰天大笑出门去
08-24 1万+
关于select函数超时时间问题 select函数使用 int select(int n,fd_set * readfds,fd_set * writefds,fd_set * exceptfds,struct timeval * timeout); 具体参数说明： 1、 int n是一个整数值，是指集合中所有文件描述符的范围，即所有文件描述符的最大值加1，不能错！在Windows中这个参数的值无所谓，可以设置不正确。 2、fd_set *readfds是指向fd_set结构的指针，这个集合中应该包括文件
Windows网络编程介绍共26页.pdf.zip
11-21
4. **I/O模型**：Windows网络编程中，有多种I/O模型可供选择，包括阻塞I/O、非阻塞I/O、I/O复用（select、poll、epoll）、信号驱动I/O和异步I/O（Asynchronous Procedure Call, APC）。每种模型有其适用场景和性能...
网络编程底层
arron121741的博客
03-03 1694
TCP，HTTP协议，负载均衡，IO模型
Windows Sockets网络编程 总计4个包，part2
11-03
第三部分（第13～17章），介绍了应用程序调试技术和工具，针对应用编程中的陷阱的建议和措施，WinSockAPI的多种操作系统平台，WinSock规范的可选功能和WinSock规范2.0中的所有新功能。 译者序 序 前言 第1章 ...
网络编程——超时检测（select（）、poll（）和 setsockopt()的设置合理的超时检测机制）
qq_57737603的博客
08-06 2363
网络编程中的超时检测是确保程序高性能和可靠性的关键一环。本文介绍了多种超时检测方法，包括使用 select()、poll() 函数，设置 setsockopt() 选项，使用时间戳和定时器，以及使用非阻塞套接字等。具体的使用方法取决于编程需求和特定的情况。合理地选择并使用这些方法，可以有效地避免程序长时间阻塞，并保障系统在网络故障或其他异常情况下的稳定运行。在进行网络编程时，请务必重视超时检测，并根据实际情况选择适合的方法，从而提高网络应用的性能和健壮性。
select实现的超时机制
qq_42303254的博客
08-14 768
网络超时检测-select（）函数
财务码农小老板
09-27 3066
select（）函数 1、利用select（）函数进行超时检测相比较于其他方式的特点是： 使用select函数实现超时检测，超时时间设置一次，只会有效一次，所以需要将其放在循环里面 2、在进行超时检测时，应注意的是select的返回值。如果利用其进行超时检测，第5个参数必然不能为 NULL ，在其不为空时，超时后返回 0 。使用select()实现超时检测 #inclu
超时检测
weixin_30394251的博客
09-07 205
将原本阻塞的函数设置一个最长阻塞时间。如果时间内条件达成则正常运行，如果仍然阻塞则视为超时，继续向下运行或产生异常 s.settimeout(sec)设置套接字的超时时间 from socket import * from time import sleep,ctime s = socket() s.bind(('127.0.0.1',8889)) s.listen(5)...
使用select为描述符设置超时
weixin_30415801的博客
04-24 121
int readable_timeo(int fd, int sec) { fd_set rset; struct timeval tv; FD_ZERO(&rset); FD_SET(fd, &rset); tv.tv_sec = sec; tv.tv_usec = 0...
accept函数_详解C++后台开发之多路复用IO模型中的select，poll和epoll函数
weixin_39632693的博客
11-26 463
1.select函数select函数原型如下：int select(int maxfdp,fd_set *readfds,fd_set *writefds,fd_set *errorfds,struct timeval*timeout);（1）参数maxfdp是一个整数值，是指集合中所有文件描述符的范围，其值为所有文件描述符的最大值加1。（2）参数timeout是select的超时时间，这个参数至...
套接字IO超时设置和使用select实现超时管理
John Will的博客
07-16 1254
在涉及套接字IO超时的设置上有一下3种方法： 1、调用alarm，它在指定的时期满时产生SIGALRM信号。这个方法涉及信号的处理，而信号处理在不同的实现上存在差异，而且可能干扰进程中现有的alarm调用。 　　程序大概框架如下所示，如果read在5s内被SIGALRM信号中断而返回，则表示超时，否则未超时、已读取到数据则取消闹钟。为了在超时时中断read函数，可以用信号处理函数来捕捉SIGA...
API请求响应超时问题
sinat_28298075的博客
05-28 3844
API请求响应超时导致本地平台等待响应超时页面卡顿体验极差 $curl = curl_init(); //在http 请求头加入 gzip压缩 curl_setopt($curl, CURLOPT_HTTPHEADER, array('Accept-Encoding:gzip')); //curl返回的结果，采用gzip解压 curl_setopt($curl, CURLOPT_ENCODING, "gzip"); curl
linux中C++实现超时检测
03-26
在 Linux 中实现 C 语言的超时检测有多种方法，这里介绍两种： 1. 基于 select 函数的超时检测 通过 select 函数可以将多个文件描述符和超时时间传入，函数会检测这些文件描述符是否准备好进行读或写，并设定一个超时时间。如果在超时时间内没有任何一个文件描述符准备好，则 select 函数返回 0。如果准备好的文件描述符数量大于 0，则 select 函数返回准备好的文件描述符数量。 使用 select 函数进行超时检测的一般流程如下： ```c fd_set fdset; struct timeval timeout; FD_ZERO(&fdset); /* 清空文件描述符集合 */ FD_SET(fd, &fdset); /* 设置要检测的文件描述符 */ timeout.tv_sec = seconds; /* 设置超时时间，单位为秒 */ timeout.tv_usec = 0; /* 调用 select 函数进行超时检测 */ if (select(fd + 1, &fdset, NULL, NULL, &timeout) == 0) { /* 超时未发生 */ } else { /* 超时发生或文件描述符准备就绪 */ } ``` 2. 基于 alarm 函数的超时检测 通过 alarm 函数可以定时向进程发送一个 SIGALRM 信号，可以设定一个定时器，在定时器时间到达时向进程发送 SIGALRM 信号。在程序中可通过注册一个 SIGALRM 信号处理函数来处理此信号。通过 alarm 函数实现超时检测的流程如下： ```c void timeout_handler(int sig) { /* 超时处理逻辑 */ } signal(SIGALRM, timeout_handler); /* 注册 SIGALRM 信号处理函数 */ alarm(duration); /* 设定定时器，duration 为超时时间，单位为秒 */ /* 调用需要超时检测的函数 */ function_to_check_timeout(); alarm(0); /* 取消定时器，避免影响其他函数操作 */ ``` 需要注意的是，在使用 alarm 函数时，需要确保被调用的函数不会阻塞同步信号，否则在超时时间到达后可能会发生不可预测的结果。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值