Nonblocking I/O and select()

This sample program illustrates a server application that uses nonblocking and the select() API.

Socket flow of events: Server that uses nonblocking I/O and select()

The following calls are used in the example:

1. The socket() API returns a socket descriptor, which represents an endpoint. The statement also identifies that the INET (Internet Protocol) address family with the TCP transport (SOCK_STREAM) is used for this socket.
2. The ioctl() API allows the local address to be reused when the server is restarted before the required wait time expires. In this example, it sets the socket to be nonblocking. All of the sockets for the incoming connections are also nonblocking because they inherit that state from the listening socket.
3. After the socket descriptor is created, the bind() gets a unique name for the socket.
4. The listen() allows the server to accept incoming client connections.
5. The server uses the accept() API to accept an incoming connection request. The accept() API call blocks indefinitely, waiting for the incoming connection to arrive.
6. The select() API allows the process to wait for an event to occur and to wake up the process when the event occurs. In this example, the select() API returns a number that represents the socket descriptors that are ready to be processed.

   0

   Indicates that the process times out. In this example, the timeout is set for 3 minutes.

   -1

   Indicates that the process has failed.

   1

   Indicates only one descriptor is ready to be processed. In this example, when a 1 is returned, the FD_ISSET and the subsequent socket calls complete only once.

   n

   Indicates that multiple descriptors are waiting to be processed. In this example, when an n is returned, the FD_ISSET and subsequent code loops and completes the requests in the order they are received by the server.

7. The accept() and recv() APIs are completed when the EWOULDBLOCK is returned.
8. The send() API echoes the data back to the client.
9. The close() API closes any open socket descriptors.

Note: By using the examples, you agree to the terms of the Code license and disclaimer information.

 #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_in6   addr;
    struct timeval       timeout;
    struct fd_set        master_set, working_set;

    /*************************************************************/
    /* Create an AF_INET6 stream socket to receive incoming      */
    /* connections on                                            */
    /*************************************************************/
    listen_sd = socket(AF_INET6, 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 nonblocking. All of the sockets for      */
    /* the incoming connections will also be nonblocking 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.sin6_family      = AF_INET6;
    memcpy(&addr.sin6_addr, &in6addr_any, sizeof(in6addr_any));
    addr.sin6_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 3 minutes for it to complete.   */
       /**********************************************************/
       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 3 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 received                          */
                   /**********************************************/
                   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);

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