IO复用的学习和练习

echo_client_select.c

  1. /**
  2.  * 说明：echo 程序的客户端
  3.  * 命令行参数：[127.0.0.1]。如果没有参数，默认使用本地回环地址
  4.  * 在输入EOF之后会半关闭：发送FIN
  5.  * 使用select 来等待stdin的输入和sockfd的相应，可以处理批量输入
  6.  */
  9. #include "../unp.h"
  10. void str_cli(FILE *fp, int sockfd);
  12. int main(int argc, char** argv) {
  14.     int sock_fd;        // 用于和服务器建立连接的套接字
  15.     struct sockaddr_in servaddr;    // 服务器的地址结构
  16.     char ipAddrStr[16] = "127.0.0.1";
  17.     char* ipAddrStrPtr;
  19.     /* 命令行读取服务器IP地址 */
  20.     if (argc == 1)
  21.         ipAddrStrPtr = ipAddrStr;
  22.     else
  23.         ipAddrStrPtr = argv[1];
  25.     /* 准备连接套接字 */
  26.     sock_fd = Socket(AF_INET, SOCK_STREAM, 0);
  27.     bzero(&servaddr, sizeof(servaddr));
  28.     servaddr.sin_family = AF_INET;
  29.     servaddr.sin_port = htons(SERV_PORT);
  30.     Inet_pton(AF_INET, ipAddrStrPtr, &servaddr.sin_addr);
  33.     Connect(sock_fd, (struct sockaddr*) &servaddr, sizeof(servaddr));
  34.     str_cli(stdin, sock_fd);
  36.     exit(0);
  37. }
  39. /**
  40.  * echo客户端的功能实现
  41.  * 参数：fp表示一个文件指针，从该文件指针中读取数据发送到服务器
  42.  * 参数：sockfd表示与服务器连接的套接字描述符
  43.  */
  44. void str_cli(FILE *fp, int sockfd)
  45. {
  46.     int maxfdp1;            // 最大文件描述符+1
  47.     int stdineof;           // stdin是否已经到达了EOF
  48.     fd_set rset;            // 需要select的文件描述符的集合
  49.     char buf[MAXLINE];      // read 和 write 使用的缓冲
  50.     int n;                  // 缓冲 buf 的有效长度
  52.     stdineof = 0;
  53.     FD_ZERO(&rset);
  54.     for (;;) {
  56.         /* 进行select */
  57.         if (stdineof == 0)
  58.             FD_SET(fileno(fp), &rset);
  59.         FD_SET(sockfd, &rset);
  60.         maxfdp1 = max(fileno(fp), sockfd) + 1;
  61.         Select(maxfdp1, &rset, NULL, NULL, NULL);   // 时间设置为NULL，表示阻塞
  63.         /* sockfd已经可以读了 */
  64.         if (FD_ISSET(sockfd, &rset)) {
  65.             if((n = Read(sockfd, buf, MAXLINE)) == 0) {
  66.                 if (stdineof == 1)
  67.                     return;
  68.                 else
  69.                     err_quit("str_cli: server terminated permaturely");
  70.             }
  71.             Write(fileno(stdout), buf, n);
  72.         }
  74.         /* fp的数据已经准备好了 */
  75.         if (FD_ISSET(fileno(fp), &rset)) {
  76.             if ((n = Read(fileno(fp), buf, MAXLINE)) == 0) {
  77.                 stdineof = 1; 
  78.                 Shutdown(sockfd, SHUT_WR);  // 半关闭，不再写了，向服务器发送FIN
  79.                 FD_CLR(fileno(fp), &rset);
  80.                 continue;
  81.             }
  82.             Writen(sockfd, buf, n);
  83.         }
  84.     }
  85. }

echo_server_poll.c

  1. #include "../unp.h"
  2. # define OPEN_MAX 256       // <limits.h>中并没有OPEN_MAX的定义
  4. /**
  5.  * echo服务器
  6.  * 单线程使用 poll 来处理多个连接
  7.  * 使用 client 数组表示关心的xx
  8.  */
  10. int main(int argc, char**argv) {
  12.     struct pollfd client[OPEN_MAX];
  13.     int sockfd;                     // client 数组中的元素
  14.     int i;                          // client 数组的临时下标
  15.     int clientMaxValid_i;           // client 数组中有效连接的最大下标
  16.     int nready;                     // select 返回后，准备好的描述符的数量
  18.     char buffer[MAXLINE];           // 存放临时数据的数组
  19.     ssize_t bufferSize;             // 临时数据的大小
  21.     int connfd;                     // listen 到的新连接
  22.     int listenfd;
  23.     socklen_t clilen;
  24.     struct sockaddr_in cliaddr, servaddr;
  26.     /* 服务器Listen */
  27.     listenfd = Socket(AF_INET, SOCK_STREAM, 0);
  28.     bzero(&servaddr, sizeof(servaddr));
  29.     servaddr.sin_family = AF_INET;
  30.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  31.     servaddr.sin_port = htons(SERV_PORT);
  32.     Bind(listenfd, (SA*)&servaddr, sizeof(servaddr));
  33.     Listen(listenfd, LISTENQ);
  35.     /* 初始化 client 集合 */
  36.     client[0].fd = listenfd;
  37.     client[0].events = POLLRDNORM;      // 关心 listenfd 是否可读
  38.     for (i = 1; i < OPEN_MAX; i++)
  39.         client[i].fd = -1;      // -1 表示poll不关心的描述符/无效的描述符
  40.     clientMaxValid_i = 0;
  42.     for (;;) {
  43.         nready = Poll(client, clientMaxValid_i + 1, INFTIM);    // INFTIM表示无限阻塞
  44.         /* 每次只会监听最多一个连接请求，和若干个客户端数据发送 */
  46.         /* 监听到了客户端的连接请求 */
  47.         if (client[0].revents & POLLRDNORM) {
  48.             clilen = sizeof(cliaddr);
  49.             connfd = Accept(listenfd, (SA*)&cliaddr, &clilen);
  51.             /* 将客户端的sockfd 加入到 client集合中 */
  52.             for (i = 0; i < OPEN_MAX; i++) {
  53.                 if (client[i].fd < 0) {
  54.                     client[i].fd = connfd;
  55.                     break;
  56.                 }
  57.             }
  58.             if (i == OPEN_MAX)
  59.                 err_quit("too many clients");
  61.             /* 让 poll 关心这个sockfd */
  62.             client[i].events = POLLRDNORM;
  63.             if (i > clientMaxValid_i)
  64.                 clientMaxValid_i = i;
  66.             if (--nready <= 0)
  67.                 continue;
  68.         }
  70.         /* 客户端发来了数据 */
  71.         for (i = 0; i <= clientMaxValid_i; i++) {     // 遍历整个client集合，才能找到是哪一个客户端发来了数据
  72.             sockfd = client[i].fd;
  73.             if (sockfd < 0)
  74.                 continue;
  75.             if (client[i].revents & (POLLRDNORM | POLLERR)) {
  76.                 bufferSize = Read(sockfd, buffer, MAXLINE);
  78.                 /* 客户端连接出现了错误 */
  79.                 if (bufferSize < 0) {
  80.                     if (errno == ECONNRESET) {
  81.                         Close(sockfd);
  82.                         client[i].fd = -1;
  83.                     }
  84.                 }
  86.                 /* 客户端连接 EOF */
  87.                 else if (bufferSize == 0) {
  88.                     Close(sockfd);
  89.                     client[i].fd = -1;
  90.                 }
  91.                 else
  92.                     Writen(sockfd, buffer, bufferSize);
  94.                 if (--nready <= 0)
  95.                     break;
  96.             }
  97.         }
  98.     }
  99. }

echo_server_select.c

  1. #include "../unp.h"
  3. /**
  4.  * echo服务器
  5.  * 单线程使用select来处理多个连接
  6.  * 使用client数组，存放已经建立连接的sockfd
  7.  * 使用allset/rset，存放需要select - read的集合：包括一众客户端sockfd，以及服务器的listen sockfd
  8.  */
  10. int main(int argc, char**argv) {
  12.     int client[FD_SETSIZE];         // 已经建立连接的客户端的 sockfd 的集合；-1表示没有使用
  13.     int sockfd;                     // client 数组中的元素
  14.     int i;                          // client 数组的临时下标
  15.     int clientMaxIndex;             // client 数组中有效连接的最大下标
  17.     fd_set rset;                    // 需要select 的一系列描述符。包括listen sockfd，以及客户端连接的 sockfd
  18.     fd_set allset;                  // allset 是 rset 第一个副本。因为rset可能会被select函数改变
  19.     int maxfd;                      // rset/allset 集合中最大的描述符编号
  20.     int nready;                     // select 返回后，准备好的描述符的数量
  22.     char buffer[MAXLINE];           // 存放临时数据的数组
  23.     ssize_t bufferSize;             // 临时数据的大小
  25.     int connfd;                     // listen 到的新连接
  26.     int listenfd;
  27.     socklen_t clilen;
  28.     struct sockaddr_in cliaddr, servaddr;
  30.     /* 服务器Listen */
  31.     listenfd = Socket(AF_INET, SOCK_STREAM, 0);
  32.     bzero(&servaddr, sizeof(servaddr));
  33.     servaddr.sin_family = AF_INET;
  34.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  35.     servaddr.sin_port = htons(SERV_PORT);
  36.     Bind(listenfd, (SA*)&servaddr, sizeof(servaddr));
  37.     Listen(listenfd, LISTENQ);
  39.     /* 初始化各个集合 */
  40.     maxfd = listenfd;
  41.     clientMaxIndex = -1;
  42.     for (i = 0; i < FD_SETSIZE; i++) 
  43.         client[i] = -1;
  44.     FD_ZERO(&allset);
  45.     FD_SET(listenfd, &allset);
  48.     for (;;) {
  49.         rset = allset;
  50.         nready = Select(maxfd + 1, &rset, NULL, NULL, NULL);
  51.         /* 每次只会监听最多一个连接请求，和若干个客户端数据发送 */
  53.         /* 监听到了客户端的连接请求 */
  54.         if (FD_ISSET(listenfd, &rset)) {
  55.             clilen = sizeof(cliaddr);
  56.             connfd = Accept(listenfd, (SA*)&cliaddr, &clilen);
  58.             /* 将客户端的sockfd 加入到 client集合中 */
  59.             for (i = 0; i < FD_SETSIZE; i++) {
  60.                 if (client[i] < 0) {
  61.                     client[i] = connfd;
  62.                     break;
  63.                 }
  64.             }
  65.             if (i == FD_SETSIZE)
  66.                 err_quit("too many clients");
  68.             /* 将客户端的 sockfd 加入 allset集合中。同时更新maxfd，maxi */
  69.             FD_SET(connfd, &allset);
  70.             if (connfd > maxfd)
  71.                 maxfd = connfd;
  72.             if (i > clientMaxIndex)
  73.                 clientMaxIndex = i;
  75.             if (--nready <= 0)
  76.                 continue;
  77.         }
  79.         /* 客户端发来了数据 */
  80.         for (i = 0; i <= clientMaxIndex; i++) {     // 遍历整个client集合，才能找到是哪一个客户端发来了数据
  81.             sockfd = client[i];
  82.             if (sockfd < 0)
  83.                 continue;
  84.             if (FD_ISSET(sockfd, &rset)) {
  85.                 bufferSize = Read(sockfd, buffer, MAXLINE);
  86.                 if (bufferSize == 0) {
  87.                     Close(sockfd);
  88.                     FD_CLR(sockfd, &allset);
  89.                     client[i] = -1;
  90.                 }
  91.                 else
  92.                     Writen(sockfd, buffer, bufferSize);
  94.                 if (--nready <= 0)
  95.                     break;
  96.             }
  97.         }
  98.     }
  99. }

简单的echo服务器和客户端

  • 服务器将收到的内容反射回客户端
  • 服务器使用子进程来处理多个连接

echo_client.c
echo_server.c