转眼又快到十一月份了，北京已经是完全进入冬天的节奏，外面冷风嗖嗖的，不过在夜深人静之时，学习永远成了我最快乐的时光，只有此时会觉得自己是如此踏实，虽说白天工作也是编一天程，但是此时的编程，是一种业余爱好，而非是生活所迫，非常享受它，好了，让享受继续。

继上次学习了select函数，这次继续对它的用法进行进一步学习，下面就首先先来回顾一下该函数：

上面是函数的原形，下面用理论阐述一下它，它可以看成是一个中心管理器，能够统一管理多个I/O，一旦其中的一个或多个I/O产生了我们所感兴趣的事件，就会被select检测到并返回，再来回顾一下参数，第一个参数是nfds，表示感兴趣的文件描述符的最大值+1，这里多解释一下，为什么是最大值+1呢？实际上select函数是在遍历它所感兴趣的文件描述符是否产生了事件，是从0开始遍历，至nfds的一个[0,nfds)的一个闭开区间，而通常我们写for循环时都会这样写：

for(i=0; i<n; i++){

//TODO

}

正好这也是一个闭开区间，所以第一个参数nfds为最大描述符+1，

第二个参数readfds：可读事件集合

第三个参数writefds：可写事件集合

第四个参数exceptfds：异常事件集合

第五个参数timeout:超时时间

关于这些参数的详细描述，可以参考上篇博文:http://www.cnblogs.com/webor2006/p/4030126.html

一旦检测到了多个事件，就需要一个一个遍历它，一一处理这些I/O事件，通常将用select实现的服务器称之为并发服务器。为啥叫并发服务器呢？因为当我们检测到多个I/O事件之后，实际上是无法并行处理这些I/O事件。实际上select处理事件是按顺序执行的，比如产生了三个事件，则是先执行第一个事件，然后再执行第二个事件，以此类推，所以说它不是并行的，而是并发，为啥是并发，是因为处理这些事件时间也不能太长，也就是说select无法实现并行处理，也就是无法充分利用多核CPU的特点，实际上对于单核的cpu来说，是根据没有并行可言的，而对于多核cpu，select是无法充分利用的，那这时该怎么办呢？可以采用多进程或多线程，关于并发与并行处理，这个之后会研究，这里先大致了解一下概念既可。

上节中用select改进了回射客户端的问题，程序可以同时监测两种事件，一种是标准输入I/O事件，还一种是网络I/O，而不至于因为程序阻塞在标准输入I/O，而同时网络I/O也已经到达了而不能处理，这就是使用select的好处。

上节中只使用了读条件了，这次会对其它事件也进行学习。

以上是可读事件产生的四种情况。

下面，就用select函数来改进回射服务器程序，上节只是改进了回射客户端程序。

先来回顾一下目前的服务器程序，是每连接成功一个客户端，就会创建一个子进程出来进行处理：

这种服务器也叫做并发服务器，通过创建一个进程来达到并发的目的，当有多个客户端连接时，就会有多个进程，那有没有可能用一个进程来实现并发呢？当然是可以做到的，也就是用select，其最终原因是因为它能管理多个I/O，实际上，对于单核CPU来说，select处理并发并不会比多进程效率低，因为多进程在单核的情况下实际上还是按顺序来进行处理的，所以，下面则正式进行修改：

首先将这些代码注释掉，因为是需要改成用select实现的：

编写方法基本跟上节当中的客户端的差不多：

【提示】:记得先记住这个allset，之后随着不断加入代码逻辑，就会自然而然显现它的作用了。

接下来，由于事件成功返回了，那就可以判断标准输入listenfd是否在rset集合里，如果在集合中就证明已经检测到了事件，然后就可以分别进行判断处理了：

另外，由于这一次是单进程的实现方式，当有多个客户端连接时，其conn客户端连接信息是需要用户个数组来保存的，

  1. int main(void)
  2. {
  3. /*    signal(SIGCHLD, SIG_IGN);*/
  4.     signal(SIGCHLD, handle_sigchld);
  5.     int listenfd;
  6.     if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < )
  7. /*    if ((listenfd = socket(PF_INET, SOCK_STREAM, 0)) < 0)*/
  8.         ERR_EXIT("socket");
  9.  
  10.     struct sockaddr_in servaddr;
  11.     memset(&servaddr, , sizeof(servaddr));
  12.     servaddr.sin_family = AF_INET;
  13.     servaddr.sin_port = htons();
  14.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  15.     /*servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");*/
  16.     /*inet_aton("127.0.0.1", &servaddr.sin_addr);*/
  17.  
  18.     int on = ;
  19.     if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < )
  20.         ERR_EXIT("setsockopt");
  21.  
  22.     if (bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < )
  23.         ERR_EXIT("bind");
  24.     if (listen(listenfd, SOMAXCONN) < )
  25.         ERR_EXIT("listen");
  26.  
  27.     struct sockaddr_in peeraddr;
  28.     socklen_t peerlen = sizeof(peeraddr);
  29.     int conn;
  30.  
  31.     /*
  32.     pid_t pid;
  33.     while (1)
  34.     {
  35.         if ((conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen)) < 0)
  36.             ERR_EXIT("accept");
  37.  
  38.         printf("ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
  39.  
  40.         pid = fork();
  41.         if (pid == -1)
  42.             ERR_EXIT("fork");
  43.         if (pid == 0)
  44.         {
  45.             close(listenfd);
  46.             echo_srv(conn);
  47.             exit(EXIT_SUCCESS);
  48.         }
  49.         else
  50.             close(conn);
  51.     }
  52.     */
  53.  
  54.     int client[FD_SETSIZE];//定义一个数组用来保存conn，其中FD_SETSIZE为最大文件描述符个数，不能超过它
  55.     int i;
  56.     for (i=0; i<FD_SETSIZE; i++)//对里面的数组都初使化为-1
  57.         client[i] = -1;
  58.  
  59.     int nready;//检测到的事件个数
  60.     int maxfd = listenfd;//获取最大的文件描述符，目前listenfd最大
  61.  
  62.     fd_set rset;//声明一个可读的集合
  63.     fd_set allset;
  64.     //以下两句是将集合清空
  65.     FD_ZERO(&rset);
  66.     FD_ZERO(&allset);
  67.     FD_SET(listenfd, &allset);//将监听套接口放到allset当中
  68.     while ()
  69.     {
  70.         rset = allset;
  71.         nready = select(maxfd+, &rset, NULL, NULL, NULL);
  72.  
  73.         if (nready == -)
  74.         {
  75.             if (errno == EINTR)
  76.                 continue;
  77.  
  78.             ERR_EXIT("select");
  79.         }
  80.         if (nready == )
  81.             continue;
  82.  
  83.         if (FD_ISSET(listenfd, &rset))
  84.         {
  85.             peerlen = sizeof(peeraddr);
  86.             conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen);
  87.             if (conn == -)
  88.                 ERR_EXIT("accept");
  89.  
  90.             for (i=0; i<FD_SETSIZE; i++)//将conn放到数组当中
  91.             {
  92.                 if (client[i] < 0)
  93.                 {
  94.                     client[i] = conn;
  95.                     break;
  96.                 }
  97.             }
  98.  
  99.             if (i == FD_SETSIZE)//没有找到空闲的位置，也就是连接数已经达到了上线，则给出提示
  100.             {
  101.                 fprintf(stderr, "too many clients\n");
  102.                 exit(EXIT_FAILURE);
  103.             }
  104.         　　printf("ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));//打印输出对方的IP和端口信息
  105.         }
  106.     }
  107.  
  108.     return ;
  109. }

接下来要做一件事，这时已经得到了conn的套接口，下一次再调用select时我们也需要关心它的可读事件，这时需要做如下处理：

那思考一下为什么要用到allset这个变量？这时因为rset会被select函数所改变，所以对于所有感兴趣的事件需要存放在allset当中，

接下来，则处理已连接套接口事件了，对于这个套接口会有很多个，因为可以连接很多客户端，所以处理如下：

  1. int main(void)
  2. {
  3. /*    signal(SIGCHLD, SIG_IGN);*/
  4.     signal(SIGCHLD, handle_sigchld);
  5.     int listenfd;
  6.     if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < )
  7. /*    if ((listenfd = socket(PF_INET, SOCK_STREAM, 0)) < 0)*/
  8.         ERR_EXIT("socket");
  9.  
  10.     struct sockaddr_in servaddr;
  11.     memset(&servaddr, , sizeof(servaddr));
  12.     servaddr.sin_family = AF_INET;
  13.     servaddr.sin_port = htons();
  14.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  15.     /*servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");*/
  16.     /*inet_aton("127.0.0.1", &servaddr.sin_addr);*/
  17.  
  18.     int on = ;
  19.     if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < )
  20.         ERR_EXIT("setsockopt");
  21.  
  22.     if (bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < )
  23.         ERR_EXIT("bind");
  24.     if (listen(listenfd, SOMAXCONN) < )
  25.         ERR_EXIT("listen");
  26.  
  27.     struct sockaddr_in peeraddr;
  28.     socklen_t peerlen = sizeof(peeraddr);
  29.     int conn;
  30.  
  31.     int client[FD_SETSIZE];//定义一个数组用来保存conn，其中FD_SETSIZE为最大文件描述符个数，不能超过它
  32.     int i;
  33.     for (i=; i<FD_SETSIZE; i++)//对里面的数组都初使化为-1
  34.         client[i] = -;
  35.  
  36.     int nready;//检测到的事件个数
  37.     int maxfd = listenfd;//获取最大的文件描述符，目前listenfd最大
  38.  
  39.     fd_set rset;//声明一个可读的集合
  40.     fd_set allset;
  41.     //以下两句是将集合清空
  42.     FD_ZERO(&rset);
  43.     FD_ZERO(&allset);
  44.     FD_SET(listenfd, &allset);//将监听套接口放到allset当中
  45.     while ()
  46.     {
  47.         rset = allset;
  48.         nready = select(maxfd+, &rset, NULL, NULL, NULL);
  49.  
  50.         if (nready == -)
  51.         {
  52.             if (errno == EINTR)
  53.                 continue;
  54.  
  55.             ERR_EXIT("select");
  56.         }
  57.         if (nready == )
  58.             continue;
  59.  
  60.         if (FD_ISSET(listenfd, &rset))
  61.         {
  62.             peerlen = sizeof(peeraddr);
  63.             conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen);
  64.             if (conn == -)
  65.                 ERR_EXIT("accept");
  66.  
  67.             for (i=; i<FD_SETSIZE; i++)//将conn放到数组当中
  68.             {
  69.                 if (client[i] < )
  70.                 {
  71.                     client[i] = conn;
  72.                     break;
  73.                 }
  74.             }
  75.  
  76.             if (i == FD_SETSIZE)//没有找到空闲的位置，也就是连接数已经达到了上线，则给出提示
  77.             {
  78.                 fprintf(stderr, "too many clients\n");
  79.                 exit(EXIT_FAILURE);
  80.             }
  81.             printf("ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
  82.  
  83.             FD_SET(conn, &allset);
  84.  
  85.             if (--nready <= )
  86.                 continue;
  87.         }
  88.  
  89.         for (i=0; i<=FD_SETSIZE; i++)
  90.         {
  91.             conn = client[i];
  92.             if (conn == -1)
  93.                 continue;
  95.             if (FD_ISSET(conn, &rset))
  96.             {
  97.                 char recvbuf[1024] = {0};
  98.                 int ret = readline(conn, recvbuf, 1024);
  99.                 if (ret == -1)
  100.                     ERR_EXIT("readline");
  101.                 if (ret == 0)
  102.                 {//对方关闭
  103.                     printf("client close\n");
  104.                     FD_CLR(conn, &allset);//从集合中将此已连接接口清除
  105.                     client[i] = -1;//并且还原默认标识
  106.                 }
  108.                 fputs(recvbuf, stdout);
  109.                 writen(conn, recvbuf, strlen(recvbuf));
  111.                 if (--nready <= 0)
  112.                     break;
  114.             }
  115.         }
  116.     }
  117.  
  118.     return ;
  119. }

另外，还需要关心一下最大描述符maxfd，当产生了新的连接套接口时，是需要将其进行更新的，于是修改代码如下:

好了，下面来编译运行一下：

可见，用单进程的方式也实现了多个客户端并发的处理。

另外，此处程序还有可优化的地方，就是处理已连接事件的时候，总是遍历FD_SETSIZE，可以再加一个变量，用来记录最大的不空闲的i值，修改代码如下：

  1. int main(void)
  2. {
  3. /*    signal(SIGCHLD, SIG_IGN);*/
  4.     signal(SIGCHLD, handle_sigchld);
  5.     int listenfd;
  6.     if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < )
  7. /*    if ((listenfd = socket(PF_INET, SOCK_STREAM, 0)) < 0)*/
  8.         ERR_EXIT("socket");
  9.  
  10.     struct sockaddr_in servaddr;
  11.     memset(&servaddr, , sizeof(servaddr));
  12.     servaddr.sin_family = AF_INET;
  13.     servaddr.sin_port = htons();
  14.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  15.     /*servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");*/
  16.     /*inet_aton("127.0.0.1", &servaddr.sin_addr);*/
  17.  
  18.     int on = ;
  19.     if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < )
  20.         ERR_EXIT("setsockopt");
  21.  
  22.     if (bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < )
  23.         ERR_EXIT("bind");
  24.     if (listen(listenfd, SOMAXCONN) < )
  25.         ERR_EXIT("listen");
  26.  
  27.     struct sockaddr_in peeraddr;
  28.     socklen_t peerlen = sizeof(peeraddr);
  29.     int conn;
  30.  
  31.     int client[FD_SETSIZE];//定义一个数组用来保存conn，其中FD_SETSIZE为最大文件描述符个数，不能超过它
  32.     int maxi = 0;//用来记录最大的可连接套接口存放的位置
  33.     int i;
  34.     for (i=; i<FD_SETSIZE; i++)//对里面的数组都初使化为-1
  35.         client[i] = -;
  36.  
  37.     int nready;//检测到的事件个数
  38.     int maxfd = listenfd;//获取最大的文件描述符，目前listenfd最大
  39.  
  40.     fd_set rset;//声明一个可读的集合
  41.     fd_set allset;
  42.     //以下两句是将集合清空
  43.     FD_ZERO(&rset);
  44.     FD_ZERO(&allset);
  45.     FD_SET(listenfd, &allset);//将监听套接口放到allset当中
  46.     while ()
  47.     {
  48.         rset = allset;
  49.         nready = select(maxfd+, &rset, NULL, NULL, NULL);
  50.  
  51.         if (nready == -)
  52.         {
  53.             if (errno == EINTR)
  54.                 continue;
  55.  
  56.             ERR_EXIT("select");
  57.         }
  58.         if (nready == )
  59.             continue;
  60.  
  61.         if (FD_ISSET(listenfd, &rset))
  62.         {
  63.             peerlen = sizeof(peeraddr);
  64.             conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen);
  65.             if (conn == -)
  66.                 ERR_EXIT("accept");
  67.  
  68.             for (i=; i<FD_SETSIZE; i++)//将conn放到数组当中
  69.             {
  70.                 if (client[i] < )
  71.                 {
  72.                     client[i] = conn;
  73.                     if (i > maxi)
  74.                         maxi = i;
  75.                     break;
  76.                 }
  77.             }
  78.  
  79.             if (i == FD_SETSIZE)//没有找到空闲的位置，也就是连接数已经达到了上线，则给出提示
  80.             {
  81.                 fprintf(stderr, "too many clients\n");
  82.                 exit(EXIT_FAILURE);
  83.             }
  84.             printf("ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
  85.  
  86.             FD_SET(conn, &allset);
  87.             if (conn > maxfd)
  88.                 maxfd = conn;
  89.  
  90.             if (--nready <= )
  91.                 continue;
  92.         }
  93.  
  94.         for (i=; i<=maxi; i++)//这时就会减少循环的次数
  95.         {
  96.             conn = client[i];
  97.             if (conn == -)
  98.                 continue;
  99.  
  100.             if (FD_ISSET(conn, &rset))
  101.             {
  102.                 char recvbuf[] = {};
  103.                 int ret = readline(conn, recvbuf, );
  104.                 if (ret == -)
  105.                     ERR_EXIT("readline");
  106.                 if (ret == )
  107.                 {//对方关闭
  108.                     printf("client close\n");
  109.                     FD_CLR(conn, &allset);//从集合中将此已连接接口清除
  110.                     client[i] = -;//并且还原默认标识
  111.                 }
  112.  
  113.                 fputs(recvbuf, stdout);
  114.                 writen(conn, recvbuf, strlen(recvbuf));
  115.  
  116.                 if (--nready <= )
  117.                     break;
  118.  
  119.             }
  120.         }
  121.     }
  122.  
  123.     return ;
  124. }

最后再来看一下整个服务端的代码如下：

echosrv.c:

  1. #include <unistd.h>
  2. #include <sys/types.h>
  3. #include <sys/socket.h>
  4. #include <netinet/in.h>
  5. #include <arpa/inet.h>
  6. #include <signal.h>
  7. #include <sys/wait.h>
  8.  
  9. #include <stdlib.h>
  10. #include <stdio.h>
  11. #include <errno.h>
  12. #include <string.h>
  13.  
  14. #define ERR_EXIT(m) \
  15.         do \
  16.         { \
  17.                 perror(m); \
  18.                 exit(EXIT_FAILURE); \
  19.         } while()
  20.  
  21. ssize_t readn(int fd, void *buf, size_t count)
  22. {
  23.     size_t nleft = count;
  24.     ssize_t nread;
  25.     char *bufp = (char*)buf;
  26.  
  27.     while (nleft > )
  28.     {
  29.         if ((nread = read(fd, bufp, nleft)) < )
  30.         {
  31.             if (errno == EINTR)
  32.                 continue;
  33.             return -;
  34.         }
  35.         else if (nread == )
  36.             return count - nleft;
  37.  
  38.         bufp += nread;
  39.         nleft -= nread;
  40.     }
  41.  
  42.     return count;
  43. }
  44.  
  45. ssize_t writen(int fd, const void *buf, size_t count)
  46. {
  47.     size_t nleft = count;
  48.     ssize_t nwritten;
  49.     char *bufp = (char*)buf;
  50.  
  51.     while (nleft > )
  52.     {
  53.         if ((nwritten = write(fd, bufp, nleft)) < )
  54.         {
  55.             if (errno == EINTR)
  56.                 continue;
  57.             return -;
  58.         }
  59.         else if (nwritten == )
  60.             continue;
  61.  
  62.         bufp += nwritten;
  63.         nleft -= nwritten;
  64.     }
  65.  
  66.     return count;
  67. }
  68.  
  69. ssize_t recv_peek(int sockfd, void *buf, size_t len)
  70. {
  71.     while ()
  72.     {
  73.         int ret = recv(sockfd, buf, len, MSG_PEEK);
  74.         if (ret == - && errno == EINTR)
  75.             continue;
  76.         return ret;
  77.     }
  78. }
  79.  
  80. ssize_t readline(int sockfd, void *buf, size_t maxline)
  81. {
  82.     int ret;
  83.     int nread;
  84.     char *bufp = buf;
  85.     int nleft = maxline;
  86.     while ()
  87.     {
  88.         ret = recv_peek(sockfd, bufp, nleft);
  89.         if (ret < )
  90.             return ret;
  91.         else if (ret == )
  92.             return ret;
  93.  
  94.         nread = ret;
  95.         int i;
  96.         for (i=; i<nread; i++)
  97.         {
  98.             if (bufp[i] == '\n')
  99.             {
  100.                 ret = readn(sockfd, bufp, i+);
  101.                 if (ret != i+)
  102.                     exit(EXIT_FAILURE);
  103.  
  104.                 return ret;
  105.             }
  106.         }
  107.  
  108.         if (nread > nleft)
  109.             exit(EXIT_FAILURE);
  110.  
  111.         nleft -= nread;
  112.         ret = readn(sockfd, bufp, nread);
  113.         if (ret != nread)
  114.             exit(EXIT_FAILURE);
  115.  
  116.         bufp += nread;
  117.     }
  118.  
  119.     return -;
  120. }
  121.  
  122. void echo_srv(int conn)
  123. {
  124.     char recvbuf[];
  125.         while ()
  126.         {
  127.                 memset(recvbuf, , sizeof(recvbuf));
  128.                 int ret = readline(conn, recvbuf, );
  129.         if (ret == -)
  130.             ERR_EXIT("readline");
  131.         if (ret == )
  132.         {
  133.             printf("client close\n");
  134.             break;
  135.         }
  136.  
  137.                 fputs(recvbuf, stdout);
  138.                 writen(conn, recvbuf, strlen(recvbuf));
  139.         }
  140. }
  141.  
  142. void handle_sigchld(int sig)
  143. {
  144. /*    wait(NULL);*/
  145.     while (waitpid(-, NULL, WNOHANG) > )
  146.         ;
  147. }
  148.  
  149. int main(void)
  150. {
  151. /*    signal(SIGCHLD, SIG_IGN);*/
  152.     signal(SIGCHLD, handle_sigchld);
  153.     int listenfd;
  154.     if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < )
  155. /*    if ((listenfd = socket(PF_INET, SOCK_STREAM, 0)) < 0)*/
  156.         ERR_EXIT("socket");
  157.  
  158.     struct sockaddr_in servaddr;
  159.     memset(&servaddr, , sizeof(servaddr));
  160.     servaddr.sin_family = AF_INET;
  161.     servaddr.sin_port = htons();
  162.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  163.     /*servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");*/
  164.     /*inet_aton("127.0.0.1", &servaddr.sin_addr);*/
  165.  
  166.     int on = ;
  167.     if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < )
  168.         ERR_EXIT("setsockopt");
  169.  
  170.     if (bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < )
  171.         ERR_EXIT("bind");
  172.     if (listen(listenfd, SOMAXCONN) < )
  173.         ERR_EXIT("listen");
  174.  
  175.     struct sockaddr_in peeraddr;
  176.     socklen_t peerlen = sizeof(peeraddr);
  177.     int conn;
  178.  
  179.     int client[FD_SETSIZE];//定义一个数组用来保存conn，其中FD_SETSIZE为最大文件描述符个数，不能超过它
  180.     int maxi = ;//用来记录最大的可连接套接口存放的位置
  181.     int i;
  182.     for (i=; i<FD_SETSIZE; i++)//对里面的数组都初使化为-1
  183.         client[i] = -;
  184.  
  185.     int nready;//检测到的事件个数
  186.     int maxfd = listenfd;//获取最大的文件描述符，目前listenfd最大
  187.  
  188.     fd_set rset;//声明一个可读的集合
  189.     fd_set allset;
  190.     //以下两句是将集合清空
  191.     FD_ZERO(&rset);
  192.     FD_ZERO(&allset);
  193.     FD_SET(listenfd, &allset);//将监听套接口放到allset当中
  194.     while ()
  195.     {
  196.         rset = allset;
  197.         nready = select(maxfd+, &rset, NULL, NULL, NULL);
  198.  
  199.         if (nready == -)
  200.         {
  201.             if (errno == EINTR)
  202.                 continue;
  203.  
  204.             ERR_EXIT("select");
  205.         }
  206.         if (nready == )
  207.             continue;
  208.  
  209.         if (FD_ISSET(listenfd, &rset))
  210.         {
  211.             peerlen = sizeof(peeraddr);
  212.             conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen);
  213.             if (conn == -)
  214.                 ERR_EXIT("accept");
  215.  
  216.             for (i=; i<FD_SETSIZE; i++)//将conn放到数组当中
  217.             {
  218.                 if (client[i] < )
  219.                 {
  220.                     client[i] = conn;
  221.                     if (i > maxi)
  222.                         maxi = i;
  223.                     break;
  224.                 }
  225.             }
  226.  
  227.             if (i == FD_SETSIZE)//没有找到空闲的位置，也就是连接数已经达到了上线，则给出提示
  228.             {
  229.                 fprintf(stderr, "too many clients\n");
  230.                 exit(EXIT_FAILURE);
  231.             }
  232.             printf("ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
  233.  
  234.             FD_SET(conn, &allset);
  235.             if (conn > maxfd)
  236.                 maxfd = conn;
  237.  
  238.             if (--nready <= )
  239.                 continue;
  240.         }
  241.  
  242.         for (i=; i<=maxi; i++)
  243.         {
  244.             conn = client[i];
  245.             if (conn == -)
  246.                 continue;
  247.  
  248.             if (FD_ISSET(conn, &rset))
  249.             {
  250.                 char recvbuf[] = {};
  251.                 int ret = readline(conn, recvbuf, );
  252.                 if (ret == -)
  253.                     ERR_EXIT("readline");
  254.                 if (ret == )
  255.                 {//对方关闭
  256.                     printf("client close\n");
  257.                     FD_CLR(conn, &allset);//从集合中将此已连接接口清除
  258.                     client[i] = -;//并且还原默认标识
  259.                 }
  260.  
  261.                 fputs(recvbuf, stdout);
  262.                 writen(conn, recvbuf, strlen(recvbuf));
  263.  
  264.                 if (--nready <= )
  265.                     break;
  266.  
  267.             }
  268.         }
  269.     }
  270.  
  271.     return ;
  272. }

echocli.c:

  1. #include <unistd.h>
  2. #include <sys/types.h>
  3. #include <sys/socket.h>
  4. #include <netinet/in.h>
  5. #include <arpa/inet.h>
  6. #include <signal.h>
  7.  
  8. #include <stdlib.h>
  9. #include <stdio.h>
  10. #include <errno.h>
  11. #include <string.h>
  12.  
  13. #define ERR_EXIT(m) \
  14.         do \
  15.         { \
  16.                 perror(m); \
  17.                 exit(EXIT_FAILURE); \
  18.         } while()
  19.  
  20. ssize_t readn(int fd, void *buf, size_t count)
  21. {
  22.         size_t nleft = count;
  23.         ssize_t nread;
  24.         char *bufp = (char*)buf;
  25.  
  26.         while (nleft > )
  27.         {
  28.                 if ((nread = read(fd, bufp, nleft)) < )
  29.                 {
  30.                         if (errno == EINTR)
  31.                                 continue;
  32.                         return -;
  33.                 }
  34.                 else if (nread == )
  35.                         return count - nleft;
  36.  
  37.                 bufp += nread;
  38.                 nleft -= nread;
  39.         }
  40.  
  41.         return count;
  42. }
  43.  
  44. ssize_t writen(int fd, const void *buf, size_t count)
  45. {
  46.         size_t nleft = count;
  47.         ssize_t nwritten;
  48.         char *bufp = (char*)buf;
  49.  
  50.         while (nleft > )
  51.         {
  52.                 if ((nwritten = write(fd, bufp, nleft)) < )
  53.                 {
  54.                         if (errno == EINTR)
  55.                                 continue;
  56.                         return -;
  57.                 }
  58.                 else if (nwritten == )
  59.                         continue;
  60.  
  61.                 bufp += nwritten;
  62.                 nleft -= nwritten;
  63.         }
  64.  
  65.         return count;
  66. }
  67.  
  68. ssize_t recv_peek(int sockfd, void *buf, size_t len)
  69. {
  70.         while ()
  71.         {
  72.                 int ret = recv(sockfd, buf, len, MSG_PEEK);
  73.                 if (ret == - && errno == EINTR)
  74.                         continue;
  75.                 return ret;
  76.         }
  77. }
  78.  
  79. ssize_t readline(int sockfd, void *buf, size_t maxline)
  80. {
  81.         int ret;
  82.         int nread;
  83.         char *bufp = buf;
  84.         int nleft = maxline;
  85.         while ()
  86.         {
  87.                 ret = recv_peek(sockfd, bufp, nleft);
  88.                 if (ret < )
  89.                         return ret;
  90.                 else if (ret == )
  91.                         return ret;
  92.  
  93.                 nread = ret;
  94.                 int i;
  95.                 for (i=; i<nread; i++)
  96.                 {
  97.                         if (bufp[i] == '\n')
  98.                         {
  99.                                 ret = readn(sockfd, bufp, i+);
  100.                                 if (ret != i+)
  101.                                         exit(EXIT_FAILURE);
  102.  
  103.                                 return ret;
  104.                         }
  105.                 }
  106.  
  107.                 if (nread > nleft)
  108.                         exit(EXIT_FAILURE);
  109.  
  110.                 nleft -= nread;
  111.                 ret = readn(sockfd, bufp, nread);
  112.                 if (ret != nread)
  113.                         exit(EXIT_FAILURE);
  114.  
  115.                 bufp += nread;
  116.         }
  117.  
  118.         return -;
  119. }
  120.  
  121. void echo_cli(int sock)
  122. {
  123. /*
  124.     char sendbuf[1024] = {0};
  125.         char recvbuf[1024] = {0};
  126.         while (fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)
  127.         {
  128.                 writen(sock, sendbuf, strlen(sendbuf));
  129.  
  130.                 int ret = readline(sock, recvbuf, sizeof(recvbuf));
  131.                 if (ret == -1)
  132.                         ERR_EXIT("readline");
  133.                 else if (ret == 0)
  134.                 {
  135.                         printf("client close\n");
  136.                         break;
  137.                 }
  138.  
  139.                 fputs(recvbuf, stdout);
  140.                 memset(sendbuf, 0, sizeof(sendbuf));
  141.                 memset(recvbuf, 0, sizeof(recvbuf));
  142.         }
  143.  
  144.         close(sock);
  145. */
  146.  
  147.     fd_set rset;
  148.     FD_ZERO(&rset);
  149.  
  150.     int nready;
  151.     int maxfd;
  152.     int fd_stdin = fileno(stdin);
  153.     if (fd_stdin > sock)
  154.         maxfd = fd_stdin;
  155.     else
  156.         maxfd = sock;
  157.  
  158.     char sendbuf[] = {};
  159.         char recvbuf[] = {};
  160.  
  161.     while ()
  162.     {
  163.         FD_SET(fd_stdin, &rset);
  164.         FD_SET(sock, &rset);
  165.         nready = select(maxfd+, &rset, NULL, NULL, NULL);
  166.         if (nready == -)
  167.             ERR_EXIT("select");
  168.  
  169.         if (nready == )
  170.             continue;
  171.  
  172.         if (FD_ISSET(sock, &rset))
  173.         {
  174.             int ret = readline(sock, recvbuf, sizeof(recvbuf));
  175.                     if (ret == -)
  176.                             ERR_EXIT("readline");
  177.                     else if (ret == )
  178.                     {
  179.                             printf("server close\n");
  180.                             break;
  181.                     }
  182.  
  183.                        fputs(recvbuf, stdout);
  184.                     memset(recvbuf, , sizeof(recvbuf));
  185.         }
  186.         if (FD_ISSET(fd_stdin, &rset))
  187.         {
  188.             if (fgets(sendbuf, sizeof(sendbuf), stdin) == NULL)
  189.                 break;
  190.             writen(sock, sendbuf, strlen(sendbuf));
  191.             memset(sendbuf, , sizeof(sendbuf));
  192.         }
  193.     }
  194.  
  195.     close(sock);
  196. }
  197.  
  198. void handle_sigpipe(int sig)
  199. {
  200.     printf("recv a sig=%d\n", sig);
  201. }
  202.  
  203. int main(void)
  204. {
  205. /*
  206.     signal(SIGPIPE, handle_sigpipe);
  207. */
  208.     signal(SIGPIPE, SIG_IGN);
  209.     int sock;
  210.     if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < )
  211.         ERR_EXIT("socket");
  212.  
  213.     struct sockaddr_in servaddr;
  214.     memset(&servaddr, , sizeof(servaddr));
  215.     servaddr.sin_family = AF_INET;
  216.     servaddr.sin_port = htons();
  217.     servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
  218.  
  219.     if (connect(sock, (struct sockaddr*)&servaddr, sizeof(servaddr)) < )
  220.         ERR_EXIT("connect");
  221.  
  222.     struct sockaddr_in localaddr;
  223.     socklen_t addrlen = sizeof(localaddr);
  224.     if (getsockname(sock, (struct sockaddr*)&localaddr, &addrlen) < )
  225.         ERR_EXIT("getsockname");
  226.  
  227.     printf("ip=%s port=%d\n", inet_ntoa(localaddr.sin_addr), ntohs(localaddr.sin_port));
  228.  
  229.     echo_cli(sock);
  230.  
  231.     return ;
  232. }

好了，今天就先学到这，下次继续。

linux网络编程之socket编程(九)的更多相关文章

  1. linux网络编程之socket编程(四)

    经过两周的等待,终于可以回归我正常的学习之旅了,表哥来北京了在我这暂住,晚上回家了基本在和他聊天,周末带他在北京城到处乱转,几乎剥夺了我自由学习的时间了,不过,亲人之情还是很难得的,工作学习并不是生活 ...

  2. linux网络编程之socket编程(一)

    今天开始,继续来学习linux编程,这次主要是研究下linux下的网络编程,而网络编程中最基本的需从socket编程开始,下面正式开始学习: 什么是socket: 在学习套接口之前,先要回顾一下Tcp ...

  3. linux网络编程之socket编程(六)

    经过一个国庆长假,又有一段时间没有写博文了,今天继续对linux网络编程进行学习,如今的北京又全面进入雾霾天气了,让我突然想到了一句名句:“真爱生活,珍惜生命”,好了,言归正传. 回顾一下我们之间实现 ...

  4. linux网络编程之socket编程(八)

    学习socket编程继续,今天要学习的内容如下: 先来简单介绍一下这五种模型分别是哪些,偏理论,有个大致的印象就成,做个对比,因为最终只会研究一个I/O模型,也是经常会用到的, 阻塞I/O: 先用一个 ...

  5. linux网络编程之socket编程(十六)

    继续学习socket编程,今天的内容会有些难以理解,一步步来分解,也就不难了,正入正题: 实际上sockpair有点像之前linux系统编程中学习的pipe匿名管道,匿名管道它是半双工的,只能用于亲缘 ...

  6. linux网络编程之socket编程(十五)

    今天继续学习socket编程,这次主要是学习UNIX域协议相关的知识,下面开始: [有个大概的认识,它是来干嘛的] ①.UNIX域套接字与TCP套接字相比较,在同一台主机的传输速度前者是后者的两倍. ...

  7. linux网络编程之socket编程(三)

    今天继续对socket编程进行学习,在学习之前,需要回顾一下上一篇中编写的回射客户/服务器程序(http://www.cnblogs.com/webor2006/p/3923254.html),因为今 ...

  8. linux网络编程之socket编程(二)

    今天继续对socket编程进行研究,这里会真正开如用socket写一个小例子,进入正题: TCP客户/服务器模型:   关于这个模型的流程这里就不多说了,比较容易理解,下面则利用这种模型来编写一个实际 ...

  9. linux网络编程之socket编程(十二)

    今天继续学习socket编程,期待的APEC会议终于在京召开了,听说昨晚鸟巢那灯火通明,遍地礼花,有点08年奥运会的架势,有种冲动想去瞅见一下习大大的真容,"伟大的祖国,我爱你~~~&quo ...

随机推荐

  1. Socket测试工具（客户端、服务端）

    Socket是什么? SOCKET用于在两个基于TCP/IP协议的应用程序之间相互通信.最早出现在UNIX系统中,是UNIX系统主要的信息传递方式.在WINDOWS系统中,SOCKET称为WINSOC ...

  2. 【嵌入式硬件Esp32】Ubuntu 1804下ESP32交叉编译环境搭建

    一.ESP32概述EPS32是乐鑫最新推出的集成2.4GWi-Fi和蓝牙双模的单芯片方案,采用台积电(TSMC)超低功耗的40nm工艺,拥有最佳的功耗性能.射频性能.稳定性.通用性和可靠性,适用于多种 ...

  3. consul服务注册与服务发现的巨坑

    最近使用consul作为项目的服务注册与服务发现的基础功能.在塔建集群使用中遇到一些坑,下面一个个的记录下来. consul集群多node consul集群的node也就是我们所说的consul实例. ...

  4. Andrew Ng机器学习课程10补充

    Andrew Ng机器学习课程10补充 VC dimension 讲到了如果通过最小化训练误差,使用一个具有d个参数的hypothesis class进行学习,为了学习好,一般需要参数d的线性关系个训 ...

  5. [ClickOnce] - Win10 管理员模式下无法安装 ClickOnce 之解决

    Issue Windows 10 管理员模式下,点击 ClickOnce 安装程序无反应. 解决 1. 按 WIN+R 键打开“运行”窗口,输入 “gpedit.msc" 打开组策略.2.  ...

  6. PAT(B) 1029 旧键盘（Java）字符串

    题目链接:1029 旧键盘 (20 point(s)) 题目描述 旧键盘上坏了几个键,于是在敲一段文字的时候,对应的字符就不会出现.现在给出应该输入的一段文字.以及实际被输入的文字,请你列出肯定坏掉的 ...

  7. 应用编排服务之ELK技术栈示例模板详解

    日志对互联网应用的运维尤为重要,它可以帮助我们了解服务的运行状态.了解数据流量来源甚至可以帮助我们分析用户的行为等.当进行故障排查时,我们希望能够快速的进行日志查询和过滤,以便精准的定位并解决问题. ...

  8. 利用WkHtmlToPdf，把H5 转成PDF

    工具下载地址: 链接:https://pan.baidu.com/s/1TSq2WWZcvPwuIfPRHST-FA 提取码:wkx8 原理: 通过IIS访问页面,利用WkHtmlToPdf.exe, ...

  9. ASP.NET Core利用拦截器 IActionFilter实现权限控制

    “麦荻网教系统”采用了前后端代码分离的架构,即“Miidy.Cloud.Console”站与“Miidy.Cloud.Manage”站(两个前端站)同时通过web api的方式调用“Miidy.Clo ...

  10. Java源码阅读之ArrayList

    基于jdk1.8的ArrayList源码分析. 实现List接口最常见的大概就四种,ArrayList, LinkedList, Vector, Stack实现,今天就着重看一下ArrayList的源 ...