嵌入式Linux网络编程之：网络高级编程

admin

        10.3  网络高级编程

        在实际情况中，人们往往遇到多个客户端连接服务器端的情况。由于之前介绍的如connet()、recv()和send()等都是阻塞性函数，如果资源没有准备好，则调用该函数的进程将进入睡眠状态，这样就无法处理I/O多路复用的情况了。本节给出了两种解决I/O多路复用的解决方法，这两个函数都是之前学过的fcntl()和select()（请读者先复习第6章中的相关内容）。可以看到，由于在Linux中把socket也作为一种特殊文件描述符，这给用户的处理带来了很大的方便。
         
        1．fcntl()

        函数fcntl()针对socket编程提供了如下的编程特性。
        n 非阻塞I/O：可将cmd设置为F_SETFL，将lock设置为O_NONBLOCK。
        n 异步I/O：可将cmd设置为F_SETFL，将lock设置为O_ASYNC。
        下面是用fcntl()将套接字设置为非阻塞I/O的实例代码：
         
        /* net_fcntl.c */
        #include <sys/types.h>
        #include <sys/socket.h>
        #include <sys/wait.h>
        #include <stdio.h>
        #include <stdlib.h>
        #include <errno.h>
        #include <string.h>
        #include <sys/un.h>
        #include <sys/time.h>
        #include <sys/ioctl.h>
        #include <unistd.h>
        #include <netinet/in.h>
        #include <fcntl.h>
         
        #define PORT                  1234
        #define MAX_QUE_CONN_NM        5
        #define BUFFER_SIZE             1024
         
        int main()
        {
             struct sockaddr_in server_sockaddr, client_sockaddr;
             int sin_size, recvbytes, flags;
             int sockfd, client_fd;
             char buf[BUFFER_SIZE];
             
             if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
             {
                  perror("socket");
                  exit(1);
             }
             server_sockaddr.sin_family = AF_INET;
             server_sockaddr.sin_port = htons(PORT);
             server_sockaddr.sin_addr.s_addr = INADDR_ANY;
             bzero(&(server_sockaddr.sin_zero), 8);
             int i = 1;/* 允许重复使用本地地址与套接字进行绑定 */
             setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i));
             if (bind(sockfd, (struct sockaddr *)&server_sockaddr,
        sizeof(struct sockaddr)) == -1)
             {
                  perror("bind");
                  exit(1);
             }     
             if(listen(sockfd,MAX_QUE_CONN_NM) == -1)
             {
                  perror("listen");
                  exit(1);
             }
             printf("Listening....\n");
             /* 调用fcntl()函数给套接字设置非阻塞属性 */
             flags = fcntl(sockfd, F_GETFL);
             if (flags < 0 || fcntl(sockfd, F_SETFL, flags|O_NONBLOCK) < 0)
             {
                  perror("fcntl");
                  exit(1);
             }
                  
             while(1)
             {
                  sin_size = sizeof(struct sockaddr_in);
                  if ((client_fd = accept(sockfd,
                               (struct sockaddr*)&client_sockaddr, &sin_size)) < 0)
                  {
                       perror("accept");
                       exit(1);
                  }
         
                       if ((recvbytes = recv(client_fd, buf, BUFFER_SIZE, 0)) < 0)
                       {
                       perror("recv");
                       exit(1);
                  }         
                  printf("Received a message: %s\n", buf);
          } /*while*/
          
          close(client_fd);
          exit(1);
        }
         
        运行该程序，结果如下所示：
         
        $ ./net_fcntl
        Listening....
        accept: Resource temporarily unavailable
         
        可以看到，当accept()的资源不可用（没有任何未处理的等待连接的请求）时，程序就会自动返回。
         
        2．select()

        使用fcntl()函数虽然可以实现非阻塞I/O或信号驱动I/O，但在实际使用时往往会对资源是否准备完毕进行循环测试，这样就大大增加了不必要的CPU资源的占用。在这里可以使用select()函数来解决这个问题，同时，使用select()函数还可以设置等待的时间，可以说功能更加强大。下面是使用select()函数的服务器端源代码。客户端程序基本上与10.2.3小节中的例子相同，仅加入一行sleep()函数，使得客户端进程等待几秒钟才结束。
         
        /* net_select.c */
        #include <sys/types.h>
        #include <sys/socket.h>
        #include <stdio.h>
        #include <stdlib.h>
        #include <string.h>
        #include <sys/time.h>
        #include <sys/ioctl.h>
        #include <unistd.h>
        #include <netinet/in.h>
        #define PORT                 4321
        #define MAX_QUE_CONN_NM       5
        #define MAX_SOCK_FD            FD_SETSIZE
        #define BUFFER_SIZE            1024
         
        int main()
        {
             struct sockaddr_in server_sockaddr, client_sockaddr;
             int sin_size, count;
             fd_set inset, tmp_inset;
             int sockfd, client_fd, fd;
             char buf[BUFFER_SIZE];
             
             if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
             {
                  perror("socket");
                  exit(1);
             }
             server_sockaddr.sin_family = AF_INET;
             server_sockaddr.sin_port = htons(PORT);
             server_sockaddr.sin_addr.s_addr = INADDR_ANY;
             bzero(&(server_sockaddr.sin_zero), 8);
             int i = 1;/* 允许重复使用本地地址与套接字进行绑定 */
             setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i));
             if (bind(sockfd, (struct sockaddr *)&server_sockaddr,
                           sizeof(struct sockaddr)) == -1)
             {
                  perror("bind");
                  exit(1);
             }
             
             if(listen(sockfd, MAX_QUE_CONN_NM) == -1)
             {
                  perror("listen");
                  exit(1);
             }
             printf("listening....\n");
             /*将调用socket()函数的描述符作为文件描述符*/
             FD_ZERO(&inset);
             FD_SET(sockfd, &inset);
             while(1)
             {
                  tmp_inset = inset;
                  sin_size=sizeof(struct sockaddr_in);
                  memset(buf, 0, sizeof(buf));
                  /*调用select()函数*/
                  if (!(select(MAX_SOCK_FD, &tmp_inset, NULL, NULL, NULL) > 0))
                  {
                       perror("select");
                  }         
                  for (fd = 0; fd < MAX_SOCK_FD; fd++)
                  {
                       if (FD_ISSET(fd, &tmp_inset) > 0)
                       {
                            if (fd == sockfd)
                            { /* 服务端接收客户端的连接请求 */
                               if ((client_fd = accept(sockfd,
                              (struct sockaddr *)&client_sockaddr, &sin_size))== -1)
                                 {
                                    perror("accept");
                                    exit(1);
                                 }
                                 FD_SET(client_fd, &inset);
                                 printf("New connection from %d(socket)\n", client_fd);
                            }
                            else /* 处理从客户端发来的消息 */
                            {
                                 if ((count = recv(client_fd, buf, BUFFER_SIZE, 0)) > 0)
                                 {
                                      printf("Received a message from %d: %s\n",
                                                                       client_fd, buf);
                                 }
                                 else                        
                                 {
                                    close(fd);
                                    FD_CLR(fd, &inset);
                                    printf("Client %d(socket) has left\n", fd);
                                 }                        
                            }         
                       } /* end of if FD_ISSET*/
                  } /* end of for fd*/
             } /* end if while while*/     
             close(sockfd);
             exit(0);
        }
         
        运行该程序时，可以先启动服务器端，再反复运行客户端程序（这里启动两个客户端进程）即可，服务器端运行结果如下所示：
         
        $ ./server   
        listening....
        New connection from 4(socket)                 /* 接受第一个客户端的连接请求*/
        Received a message from 4: Hello,First!    /* 接收第一个客户端发送的数据*/
        New connection from 5(socket)              /* 接受第二个客户端的连接请求*/
        Received a message from 5: Hello,Second!   /* 接收第二个客户端发送的数据*/
        Client 4(socket) has left                   /* 检测到第一个客户端离线了*/
        Client 5(socket) has left                   /* 检测到第二个客户端离线了*/
        $ ./client localhost Hello,First! & ./client localhost Hello,Second