网络编程中的select优化通用C/S模型

具体细节看代码及注释

• 优化客户端

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>

#include <signal.h>

#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>

#define SERV_IP "192.168.1.110"//服务器IP
//出错处理宏定义
#define EXIT_ERR(m) \
        do \
        {  \
          perror(m); \
          exit(EXIT_FAILURE); \
        }while(0)


#define MAX_BUF 1024//缓冲区最大数


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

ssize_t readline(int sockfd, void *buf, size_t maxline)
{
        int ret;
        int nread;
        char *bufp = buf;
        int nleft = maxline;
        while (1)
        {
                ret = recv_peek(sockfd, bufp, nleft);
                if (ret < 0)
                        return ret;
                else if (ret == 0)
                        return ret;

                nread = ret;
                int i;
                for (i=0; i<nread; i++)
                {
                        if (bufp[i] == '\n')
                        {
                                ret = readn(sockfd, bufp, i+1);
                                if (ret != i+1)
                                        exit(EXIT_FAILURE);

                                return ret;
                        }
                }

                if (nread > nleft)
                        exit(EXIT_FAILURE);

                nleft -= nread;
                ret = readn(sockfd, bufp, nread);
                if (ret != nread)
                        exit(EXIT_FAILURE);

                bufp += nread;
        }

        return -1;
}

int main()
{
  int                 ret = 0;//辅助变量--用于判断各函数是否调用成功
  struct sockaddr_in  serv_addr;//要连接的服务器端地址
  int                 port;//服务器端口
  char*               ip_addr = SERV_IP;//服务器IP
  int                 sock_fd;//用语和服务器通信的套接字--链接的概念

  fd_set              rset;//select监控的文件描述符集合--这里关注两个描述符--标准输入和链接，都是读取操作
  int                 is_ready;//select返回值--是否准备好读取操作
  int                 max_fd;//文件描述符集合里面醉的文件描述符
  int                 stdin_fd;//标准输入对应的文件描述符--出于编码风格的规范，有必要没一个文件都定义一个文件描述符--尽管知道标准输入是0
  struct timeval      timeout;//等待时间

  char                send_buf[MAX_BUF]={0};//发送缓冲
  char                recv_buf[MAX_BUF]={0};//接受缓冲

  signal(SIGPIPE,SIG_IGN);//忽略SIGPIPE信号--避免对方关闭以后还写入引起的进程崩溃

  //建立套接字
  sock_fd = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
  if(sock_fd == -1)
  {
    EXIT_ERR("socket");
  }

  //初始化端口--这里更应该改成一个宏定义
  port = 8001;

  //填充服务器地址
  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_addr);

  //建立链接--没有用到连接超时检测--可改进
  ret = connect(sock_fd,(struct sockaddr *)&serv_addr,sizeof(serv_addr));
  if(ret == -1)
  {
    EXIT_ERR("connect");
  }  
  printf("Successful connected to IP: %s\t in PORT :%d\n",inet_ntoa(serv_addr.sin_addr),ntohs(serv_addr.sin_port));

  //获取标准输入的文件描述符
  stdin_fd = fileno(stdin);

  //寻找出要监控的文件描述符的最大值
  max_fd = stdin_fd > sock_fd ? stdin_fd : sock_fd;


  //设置要监听的文件描述符集合
  FD_ZERO(&rset);
  FD_SET(stdin_fd,&rset);
  FD_SET(sock_fd,&rset);


  //设置等待时间
  timeout.tv_sec = 5;
  timeout.tv_usec = 0;

  while(1)
  {
    //开始使用select监听
    FD_SET(stdin_fd,&rset);//注意，在每次重新调用select之前需要重新设置监听集合
    FD_SET(sock_fd,&rset);
    timeout.tv_sec = 5;//注意，在每次重新调用select之前需要重新赋值timeout，貌似select会将原timeout内存空间修改，起不到超时检测作用
    timeout.tv_usec = 0;
    is_ready = select(max_fd + 1,&rset,NULL,NULL,&timeout);

    if(-1 == is_ready)//select调用失败
    {
      EXIT_ERR("is_ready");
    }
    else if(0 == is_ready)//超时没有任何一个文件描述符的状态改变--变为可读
    {
      //printf("timeout\n");//调试信息
      continue;
    }


    if(FD_ISSET(sock_fd,&rset))//链接状态变化--表示服务器发送数据过来了
    {
      //printf("data coming..\n");//调试信息
      ret = readline(sock_fd,recv_buf,sizeof(recv_buf));//避免粘包
      if(-1 == ret)//调用失败
      {
        EXIT_ERR("readline");
      }
      else if(ret == 0)//对方关闭--这里很重要--服务器关闭以后，客户端也自动结束程序--不用select的话，客户端有可能一直阻塞在fgets，
                      //导致自己一直处于等待状态，服务器一直处于timewait状态，很不科学，利用select的话能及时避免fgets引起的阻塞
      {
        printf("peer close\n");
        break;
      }

      fputs(recv_buf,stdout);//打印读取到的数据
      memset(recv_buf,0,sizeof(recv_buf));//清空缓冲区以便下次读取新数据

    }

    if(FD_ISSET(stdin_fd,&rset))//标准输入状态变化--表示键盘有输入了--避免了客户端在这里阻塞，当服务器主动断开以后一直处于TIME_WAIT状态（11种状态）
    {
      if(fgets(send_buf, sizeof(send_buf), stdin) == NULL)//读取键盘输入的数据--读到文件结束符或者发生错误--准备退出客户端程序
      {
        printf("input completely\n");
        close(sock_fd);//关闭链接
        FD_CLR(stdin_fd,&rset);//清除监听集合
        break;
      }
      else //正确读取键盘输入
      {
        writen(sock_fd,send_buf,strlen(send_buf));//向服务器发送数据
        memset(send_buf,0,sizeof(send_buf));//清空缓冲区以便下次读取新数据
      }
    }

  }
  close(sock_fd);//关闭链接
  FD_CLR(stdin_fd,&rset);//清除监听集合
  return 0;
}

• 优化服务器

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>

#include <signal.h>

#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>


//出错处理宏定义
#define ERR_EXIT(m) \
        do \
        {  \
          perror(m); \
          exit(EXIT_FAILURE); \
        }while(0)


#define MAX_BUF 1024//缓冲区最大数


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

ssize_t readline(int sockfd, void *buf, size_t maxline)
{
        int ret;
        int nread;
        char *bufp = buf;
        int nleft = maxline;
        while (1)
        {
                ret = recv_peek(sockfd, bufp, nleft);
                if (ret < 0)
                        return ret;
                else if (ret == 0)
                        return ret;

                nread = ret;
                int i;
                for (i=0; i<nread; i++)
                {
                        if (bufp[i] == '\n')
                        {
                                ret = readn(sockfd, bufp, i+1);
                                if (ret != i+1)
                                        exit(EXIT_FAILURE);

                                return ret;
                        }
                }

                if (nread > nleft)
                        exit(EXIT_FAILURE);

                nleft -= nread;
                ret = readn(sockfd, bufp, nread);
                if (ret != nread)
                        exit(EXIT_FAILURE);

                bufp += nread;
        }

        return -1;
}

#define PORT 8001
int main()
{
  signal(SIGPIPE, SIG_IGN);//忽略SIGPIPE信号--避免对方关闭以后还写入引起的进程崩溃

    int listenfd;
    if ((listenfd = 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(PORT);
    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;

    int i;
    int client[FD_SETSIZE]; //支持的最大客户端连接数 数组
    int maxi = 0; //最大的不空闲的位置

    for (i=0; i<FD_SETSIZE; i++)//初始化客户端链接，全部为-1--表示没有建立链接
        client[i] = -1;

  //select函数需要用的参数--文件描述符集合、最大描述符等
    int nready;
    int maxfd = listenfd;
    fd_set      rset;
    fd_set      allset;

  //清空集合
    FD_ZERO(&rset);
    FD_ZERO(&allset);

  //将监听套接字加入集合进行监听
    FD_SET(listenfd, &allset);

  struct timeval      timeout;//等待时间

    while (1)
    {
    //这里很巧妙的技巧--用allset保存最新的集合（监听套接字+有效链接数组）--每次重新select之前都重新更新rset，再用rset进行监听
        rset = allset;注意，在每次重新调用select之前需要重新设置监听集合
    timeout.tv_sec = 1;//注意，在每次重新调用select之前需要重新赋值timeout，貌似select会将原timeout内存空间修改，起不到超时检测作用
    timeout.tv_usec = 0;
        //listenfd 可读，表示有客户端连接进来了，可以建立一个新的连接
        nready = select(maxfd+1, &rset, NULL, NULL, &timeout);
        if (nready == -1)//调用失败
        {
            if (errno == EINTR)//被其他信号中断监听--继续下一次循环监听
                continue;

            ERR_EXIT("select");
        }
        if (nready == 0)//超时--继续下一次循环监听
    {
      printf("time out\n");
            continue;
    }
        if (FD_ISSET(listenfd, &rset)) //若侦听套接口产生可读事件 说明3次握手已完成，有客户端已经连接建立
        {
            peerlen = sizeof(peeraddr);
            conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen); //处理accept
            if (conn == -1)//accept失败
                ERR_EXIT("accept");

            for (i=0; i<FD_SETSIZE; i++)//获取到有效链接以后要放入链接数组里面--检查到第一空闲位置将链接放入该位置
            {
                if (client[i] < 0)//确实之前没有存储有效链接
                {
                    client[i] = conn;
                    if (i > maxi)//更新最大不空闲位置
                        maxi = i;
                    break;//找到就不再遍历数组
                }
            }

            if (i == FD_SETSIZE)//达到内核设置的select监听上限--程序失败退出
            {
                fprintf(stderr, "too many clients\n");
                exit(EXIT_FAILURE);
            }
            printf("ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));//打印客户端地址信息

            FD_SET(conn, &allset); //把新的连接 放入集合中
            if (conn > maxfd)  //同时按照条件，更新maxfd  //维护最大描述符
                maxfd = conn;
      if (--nready <= 0)//表示只有一个文件描述符改变--不用判断链接数组元素了，就只有监听套接字改变状态
                continue;
        }

        for (i=0; i<=maxi; i++) //检测已连接的套接字conn是否可读
        {
            conn = client[i];//从当前链接数组里面取出元素
            if (conn == -1)//如果是-1表示非有效链接--进入下一个链接元素
                continue;

            if (FD_ISSET(conn, &rset)) //当前链接可读--这样就有效避免了read阻塞，同事利用轮询实现了单进程支持多并发--多个客户端的链接--用到了链接数组
            {
                char recvbuf[1024] = {0};
            int ret = readline(conn, recvbuf, 1024);//读取数据
            if (ret == -1)//读取失败
              ERR_EXIT("readline");
            else if (ret == 0)//对方关闭
            {
              printf("client close\n");
                    FD_CLR(conn, &allset); //若对方已退出 从集合中清除
                    client[i] = -1; //保存连接的数组元素 也置成-1 //也可进一步控制 若i是把maxfd，需要把maxifd变成第二大maxifd
          if(i == maxi)
            maxi = i - 1;
                    close(conn);//关闭连接
          }

            fputs(recvbuf, stdout);//正常读取--打印数据
            writen(conn, recvbuf, strlen(recvbuf));//回写到客户端
        //printf("send completely\n");//调试信息

       if (--nready <= 0)//只有一个链接变化--其余连接没有变化--退出本次循环，进行下一次监听
                  break;
            }
        }
    }   

  return 0;
}