socket中select的使用源码

下面的代码来自IBM学习网站，是学习socket通信和select使用的一个很好的源码。

server.c  服务器端

 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 #include <sys/time.h>
 #include <netinet/in.h>
 #include <errno.h>

 #define SERVER_PORT  12345

 #define TRUE             1
 #define FALSE            0

 main (int argc, char *argv[])
 {
    int    i, len, rc, on = ;
    int    listen_sd, max_sd, new_sd;
    int    desc_ready, end_server = FALSE;
    int    close_conn;
    char   buffer[];
    struct sockaddr_in   addr;
    struct timeval       timeout;
    fd_set        master_set, working_set;

    /*************************************************************/
    /* Create an AF_INET stream socket to receive incoming       */
    /* connections on                                            */
    /*************************************************************/
    listen_sd = socket(AF_INET, SOCK_STREAM, );
    if (listen_sd < )
    {
       perror("socket() failed");
       exit(-);
    }

    /*************************************************************/
    /* Allow socket descriptor to be reuseable                   */
    /*************************************************************/
    rc = setsockopt(listen_sd, SOL_SOCKET,  SO_REUSEADDR,
                    (char *)&on, sizeof(on));
    if (rc < )
    {
       perror("setsockopt() failed");
       close(listen_sd);
       exit(-);
    }

    /*************************************************************/
    /* Set socket to be non-blocking.  All of the sockets for    */
    /* the incoming connections will also be non-blocking since  */
    /* they will inherit that state from the listening socket.   */
    /*************************************************************/
    rc = ioctl(listen_sd, FIONBIO, (char *)&on);
    if (rc < )
    {
       perror("ioctl() failed");
       close(listen_sd);
       exit(-);
    }

    /*************************************************************/
    /* Bind the socket                                           */
    /*************************************************************/
    memset(&addr, , sizeof(addr));
    addr.sin_family      = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port        = htons(SERVER_PORT);
    rc = bind(listen_sd,
              (struct sockaddr *)&addr, sizeof(addr));
    if (rc < )
    {
       perror("bind() failed");
       close(listen_sd);
       exit(-);
    }

    /*************************************************************/
    /* Set the listen back log                                   */
    /*************************************************************/
    rc = listen(listen_sd, );
    if (rc < )
    {
       perror("listen() failed");
       close(listen_sd);
       exit(-);
    }

    /*************************************************************/
    /* Initialize the master fd_set                              */
    /*************************************************************/
    FD_ZERO(&master_set);
    max_sd = listen_sd;
    FD_SET(listen_sd, &master_set);

    /*************************************************************/
    /* Initialize the timeval struct to 3 minutes.  If no        */
    /* activity after 3 minutes this program will end.           */
    /*************************************************************/
    timeout.tv_sec  =  * ;
    timeout.tv_usec = ;

    /*************************************************************/
    /* Loop waiting for incoming connects or for incoming data   */
    /* on any of the connected sockets.                          */
    /*************************************************************/
    do
    {
       /**********************************************************/
       /* Copy the master fd_set over to the working fd_set.     */
       /**********************************************************/
       memcpy(&working_set, &master_set, sizeof(master_set));

       /**********************************************************/
       /* Call select() and wait 5 minutes for it to complete.   */
       /**********************************************************/
       printf("listen_sd is %d ",listen_sd);
       printf("Waiting on select()...\n");

       rc = select(max_sd + , &working_set, NULL, NULL, &timeout);

       /**********************************************************/
       /* Check to see if the select call failed.                */
       /**********************************************************/
       if (rc < )
       {
          perror("  select() failed");
          break;
       }

       /**********************************************************/
       /* Check to see if the 5 minute time out expired.         */
       /**********************************************************/
       if (rc == )
       {
          printf("  select() timed out.  End program.\n");
          break;
       }

       /**********************************************************/
       /* One or more descriptors are readable.  Need to         */
       /* determine which ones they are.                         */
       /**********************************************************/
       desc_ready = rc;
       for (i=; i <= max_sd  &&  desc_ready > ; ++i)
       {
          /*******************************************************/
          /* Check to see if this descriptor is ready            */
          /*******************************************************/
          if (FD_ISSET(i, &working_set))
          {
             /****************************************************/
             /* A descriptor was found that was readable - one   */
             /* less has to be looked for.  This is being done   */
             /* so that we can stop looking at the working set   */
             /* once we have found all of the descriptors that   */
             /* were ready.                                      */
             /****************************************************/
             desc_ready -= ;

             /****************************************************/
             /* Check to see if this is the listening socket     */
             /****************************************************/
             if (i == listen_sd)
             {
                printf("  Listening socket is readable\n");
                /*************************************************/
                /* Accept all incoming connections that are      */
                /* queued up on the listening socket before we   */
                /* loop back and call select again.              */
                /*************************************************/
                do
                {
                   /**********************************************/
                   /* Accept each incoming connection.  If       */
                   /* accept fails with EWOULDBLOCK, then we     */
                   /* have accepted all of them.  Any other      */
                   /* failure on accept will cause us to end the */
                   /* server.                                    */
                   /**********************************************/
                   new_sd = accept(listen_sd, NULL, NULL);
                   if (new_sd < )
                   {
                      if (errno != EWOULDBLOCK)
                      {
                         perror("  accept() failed");
                         end_server = TRUE;
                      }
                      break;
                   }

                   /**********************************************/
                   /* Add the new incoming connection to the     */
                   /* master read set                            */
                   /**********************************************/
                   printf("  New incoming connection - %d\n", new_sd);
                   FD_SET(new_sd, &master_set);
                   if (new_sd > max_sd)
                      max_sd = new_sd;

                   /**********************************************/
                   /* Loop back up and accept another incoming   */
                   /* connection                                 */
                   /**********************************************/
                } while (new_sd != -);
             }

             /****************************************************/
             /* This is not the listening socket, therefore an   */
             /* existing connection must be readable             */
             /****************************************************/
             else
             {
                printf("  Descriptor %d is readable\n", i);
                close_conn = FALSE;
                /*************************************************/
                /* Receive all incoming data on this socket      */
                /* before we loop back and call select again.    */
                /*************************************************/
                do
                {
                   /**********************************************/
                   /* Receive data on this connection until the  */
                   /* recv fails with EWOULDBLOCK.  If any other */
                   /* failure occurs, we will close the          */
                   /* connection.                                */
                   /**********************************************/
                   rc = recv(i, buffer, sizeof(buffer), );
                   if (rc < )
                   {
                      if (errno != EWOULDBLOCK)
                      {
                         perror("  recv() failed");
                         close_conn = TRUE;
                      }
                      break;
                   }

                   /**********************************************/
                   /* Check to see if the connection has been    */
                   /* closed by the client                       */
                   /**********************************************/
                   if (rc == )
                   {
                      printf("  Connection closed\n");
                      close_conn = TRUE;
                      break;
                   }

                   /**********************************************/
                   /* Data was recevied                          */
                   /**********************************************/
                   len = rc;
                   printf("  %d bytes received\n", len);

                   /**********************************************/
                   /* Echo the data back to the client           */
                   /**********************************************/
                   rc = send(i, buffer, len, );
                   if (rc < )
                   {
                      perror("  send() failed");
                      close_conn = TRUE;
                      break;
                   }

                } while (TRUE);

                /*************************************************/
                /* If the close_conn flag was turned on, we need */
                /* to clean up this active connection.  This     */
                /* clean up process includes removing the        */
                /* descriptor from the master set and            */
                /* determining the new maximum descriptor value  */
                /* based on the bits that are still turned on in */
                /* the master set.                               */
                /*************************************************/
                if (close_conn)
                {
                   close(i);
                   FD_CLR(i, &master_set);
                   if (i == max_sd)
                   {
                      while (FD_ISSET(max_sd, &master_set) == FALSE)
                         max_sd -= ;
                   }
                }
             } /* End of existing connection is readable */
          } /* End of if (FD_ISSET(i, &working_set)) */
       } /* End of loop through selectable descriptors */

    } while (end_server == FALSE);

    /*************************************************************/
    /* Cleanup all of the sockets that are open                  */
    /*************************************************************/
    for (i=; i <= max_sd; ++i)
    {
       if (FD_ISSET(i, &master_set))
          close(i);
    }
 }

client.c 客户端

 /**************************************************************************/
 /* Generic client example is used with connection-oriented server designs */
 /**************************************************************************/
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/socket.h>
 #include <netinet/in.h>

 #define SERVER_PORT  12345

 main (int argc, char *argv[])
 {
    int    len, rc;
    int    sockfd;
    char   send_buf[];
    char   recv_buf[];
    struct sockaddr_in   addr;

    /*************************************************/
    /* Create an AF_INET stream socket               */
    /*************************************************/
    sockfd = socket(AF_INET, SOCK_STREAM, );
    if (sockfd < )
    {
       perror("socket");
       exit(-);
    }

    /*************************************************/
    /* Initialize the socket address structure       */
    /*************************************************/
    memset(&addr, , sizeof(addr));
    addr.sin_family      = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port        = htons(SERVER_PORT);

    /*************************************************/
    /* Connect to the server                         */
    /*************************************************/
    rc = connect(sockfd,
                 (struct sockaddr *)&addr,
                 sizeof(struct sockaddr_in));
    if (rc < )
    {
       perror("connect");
       close(sockfd);
       exit(-);
    }
    printf("Connect completed.socketfd is %d .rc is %d \n",sockfd,rc);

    /*************************************************/
    /* Enter data buffer that is to be sent          */
    /*************************************************/
    printf("Enter message to be sent:\n");
    gets(send_buf);

    /*************************************************/
    /* Send data buffer to the worker job            */
    /*************************************************/
    len = send(sockfd, send_buf, strlen(send_buf) + , );
    if (len != strlen(send_buf) + )
    {
       perror("send");
       close(sockfd);
       exit(-);
    }
    printf("%d bytes sent\n", len);

    /*************************************************/
    /* Receive data buffer from the worker job       */
    /*************************************************/
    len = recv(sockfd, recv_buf, sizeof(recv_buf), );
    if (len != strlen(send_buf) + )
    {
       perror("recv");
       close(sockfd);
       exit(-);
    }
    printf("%d bytes received\n", len);

    /*************************************************/
    /* Close down the socket                         */
    /*************************************************/
    close(sockfd);
 }