Switch to SpeakEasy.net DSL

The Modular Manual Browser

Home Page
Manual: (Debian-5.0)
Apropos / Subsearch:
optional field

SELECT_TUT(2)              Linux Programmer's Manual             SELECT_TUT(2)

       select,  pselect,  FD_CLR,  FD_ISSET, FD_SET, FD_ZERO - synchronous I/O

       /* According to POSIX.1-2001 */
       #include <&lt;sys/select.h>&gt;

       /* According to earlier standards */
       #include <&lt;sys/time.h>&gt;
       #include <&lt;sys/types.h>&gt;
       #include <&lt;unistd.h>&gt;

       int select(int nfds, fd_set *readfds, fd_set *writefds,
                  fd_set *exceptfds, struct timeval *utimeout);

       void FD_CLR(int fd, fd_set *set);
       int  FD_ISSET(int fd, fd_set *set);
       void FD_SET(int fd, fd_set *set);
       void FD_ZERO(fd_set *set);

       #include <&lt;sys/select.h>&gt;

       int pselect(int nfds, fd_set *readfds, fd_set *writefds,
                   fd_set *exceptfds, const struct timespec *ntimeout,
                   const sigset_t *sigmask);

   Feature Test Macro Requirements for glibc (see feature_test_macros(7)):

       pselect(): _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600

       select() (or pselect()) is the pivot function of most C  programs  that
       handle more than one simultaneous file descriptor (or socket handle) in
       an efficient manner.  Its principal arguments are three arrays of  file
       descriptors:  readfds,  writefds, and exceptfds.  The way that select()
       is usually used is to block while waiting for a "change of  status"  on
       one or more of the file descriptors.  A "change of status" is when more
       characters become available from the file  descriptor,  or  when  space
       becomes  available  within the kernel's internal buffers for more to be
       written to the file descriptor, or when a  file  descriptor  goes  into
       error  (in  the  case of a socket or pipe this is when the other end of
       the connection is closed).

       In summary, select() just watches multiple file descriptors, and is the
       standard Unix call to do so.

       The  arrays  of file descriptors are called file descriptor sets.  Each
       set is declared as type fd_set, and its contents can  be  altered  with
       the macros FD_CLR(), FD_ISSET(), FD_SET(), and FD_ZERO().  FD_ZERO() is
       usually the first function to be used on a newly declared set.   There-
       after,  the  individual file descriptors that you are interested in can
       be added one by one with FD_SET().  select() modifies the  contents  of
       the sets according to the rules described below; after calling select()
       you can test if your file descriptor is still present in the  set  with
       the FD_ISSET() macro.  FD_ISSET() returns non-zero if the descriptor is
       present and zero if it is not.  FD_CLR() removes a file descriptor from
       the set.

              This set is watched to see if data is available for reading from
              any of its  file  descriptors.   After  select()  has  returned,
              readfds will be cleared of all file descriptors except for those
              that are immediately available for reading with a  recv(2)  (for
              sockets) or read(2) (for pipes, files, and sockets) call.

              This  set  is  watched to see if there is space to write data to
              any of its  file  descriptors.   After  select()  has  returned,
              writefds  will  be  cleared  of  all file descriptors except for
              those that are immediately available for writing with a  send(2)
              (for sockets) or write(2) (for pipes, files, and sockets) call.

              This  set is watched for exceptions or errors on any of the file
              descriptors.  However, that is actually just a rumor.   How  you
              use  exceptfds is to watch for out-of-band (OOB) data.  OOB data
              is data sent on a socket  using  the  MSG_OOB  flag,  and  hence
              exceptfds  only  really  applies  to  sockets.   See recv(2) and
              send(2) about this.  After select() has returned, exceptfds will
              be  cleared  of  all  file descriptors except for those that are
              available for reading OOB data.  You can only ever read one byte
              of OOB data though (which is done with recv(2)), and writing OOB
              data (done with send(2)) can be done at any time  and  will  not
              block.   Hence  there  is no need for a fourth set to check if a
              socket is available for writing OOB data.

       nfds   This is an integer  one  more  than  the  maximum  of  any  file
              descriptor  in  any  of the sets.  In other words, while you are
              busy adding file descriptors to your sets,  you  must  calculate
              the  maximum  integer  value of all of them, then increment this
              value by one, and then pass this as nfds to select().

              This is the longest time select()  may  wait  before  returning,
              even  if  nothing interesting happened.  If this value is passed
              as NULL, then select() blocks indefinitely waiting for an event.
              utimeout  can  be  set to zero seconds, which causes select() to
              return immediately.  The structure struct timeval is defined as:

                  struct timeval {
                      time_t tv_sec;    /* seconds */
                      long tv_usec;     /* microseconds */

              This argument has the same meaning as utimeout but struct  time-
              spec has nanosecond precision as follows:

                  struct timespec {
                      long tv_sec;    /* seconds */
                      long tv_nsec;   /* nanoseconds */

              This argument holds a set of signals to allow while performing a
              pselect() call (see sigaddset(3) and sigprocmask(2)).  It can be
              passed  as  NULL,  in  which  case it does not modify the set of
              allowed signals on entry and exit to the function.  It will then
              behave just like select().

   Combining Signal and Data Events
       pselect()  must be used if you are waiting for a signal as well as data
       from a file descriptor.  Programs that receive signals as  events  nor-
       mally  use  the signal handler only to raise a global flag.  The global
       flag will indicate that the event must be processed in the main loop of
       the  program.   A signal will cause the select() (or pselect()) call to
       return with errno set to EINTR.  This behavior  is  essential  so  that
       signals  can  be  processed  in the main loop of the program, otherwise
       select() would block indefinitely.  Now, somewhere  in  the  main  loop
       will  be  a conditional to check the global flag.  So we must ask: what
       if a signal arrives after the  conditional,  but  before  the  select()
       call?   The  answer  is  that  select()  would block indefinitely, even
       though an event is actually pending.  This race condition is solved  by
       the pselect() call.  This call can be used to mask out signals that are
       not to be received except within the pselect() call.  For instance, let
       us  say  that  the  event  in question was the exit of a child process.
       Before the start of the main loop, we would block  SIGCHLD  using  sig-
       procmask(2).  Our pselect() call would enable SIGCHLD by using the vir-
       gin signal mask.  Our program would look like:

       int child_events = 0;

       child_sig_handler(int x)
           signal(SIGCHLD, child_sig_handler);

       main(int argc, char **argv)
           sigset_t sigmask, orig_sigmask;

           sigaddset(&sigmask, SIGCHLD);
           sigprocmask(SIG_BLOCK, &sigmask, &orig_sigmask);

           signal(SIGCHLD, child_sig_handler);

           for (;;) { /* main loop */
               for (; child_events > 0; child_events--) {
                   /* do event work here */
               r = pselect(nfds, &rd, &wr, &er, 0, &orig_sigmask);

               /* main body of program */

       So what is the point of select()?  Can't I just read and  write  to  my
       descriptors  whenever I want?  The point of select() is that it watches
       multiple descriptors at the same time and properly puts the process  to
       sleep if there is no activity.  It does this while enabling you to han-
       dle multiple simultaneous pipes and sockets.   Unix  programmers  often
       find  themselves  in a position where they have to handle I/O from more
       than one file descriptor where the data flow may be  intermittent.   If
       you were to merely create a sequence of read(2) and write(2) calls, you
       would find that one of your calls may block waiting for data from/to  a
       file  descriptor, while another file descriptor is unused though avail-
       able for data.  select() efficiently copes with this situation.

       A simple example of the use of select() can be found in  the  select(2)
       manual page.

   Select Law
       Many people who try to use select() come across behavior that is diffi-
       cult to understand and produces  non-portable  or  borderline  results.
       For  instance,  the  above program is carefully written not to block at
       any point, even though it does not set its  file  descriptors  to  non-
       blocking  mode  at  all (see ioctl(2)).  It is easy to introduce subtle
       errors that will remove the advantage of using select(), hence  I  will
       present a list of essentials to watch for when using the select() call.

       1.  You should always try to use select() without a timeout.  Your pro-
           gram should have nothing to do if there is no data available.  Code
           that  depends  on timeouts is not usually portable and is difficult
           to debug.

       2.  The value nfds  must  be  properly  calculated  for  efficiency  as
           explained above.

       3.  No file descriptor must be added to any set if you do not intend to
           check its result after the select()  call,  and  respond  appropri-
           ately.  See next rule.

       4.  After  select() returns, all file descriptors in all sets should be
           checked to see if they are ready.

       5.  The functions read(2), recv(2), write(2), and send(2) do not neces-
           sarily  read/write the full amount of data that you have requested.
           If they do read/write the full amount, it's because you have a  low
           traffic load and a fast stream.  This is not always going to be the
           case.  You should cope with the case of your functions only  manag-
           ing to send or receive a single byte.

       6.  Never  read/write  only  in  single  bytes at a time unless you are
           really sure that you have a small amount of data to process.  It is
           extremely  inefficient  not  to  read/write as much data as you can
           buffer each time.  The buffers in the example above are 1024  bytes
           although they could easily be made larger.

       7.  The  functions  read(2),  recv(2), write(2), and send(2) as well as
           the select() call can return -1 with errno set to  EINTR,  or  with
           errno  set to EAGAIN (EWOULDBLOCK).  These results must be properly
           managed (not done properly above).  If your program is not going to
           receive  any  signals,  then it is unlikely you will get EINTR.  If
           your program does not  set  non-blocking  I/O,  you  will  not  get
           EAGAIN.   Nonetheless  you  should still cope with these errors for

       8.  Never call read(2), recv(2), write(2), or  send(2)  with  a  buffer
           length of zero.

       9.  If  the functions read(2), recv(2), write(2), and send(2) fail with
           errors other than those listed in 7., or one of the input functions
           returns  0,  indicating  end of file, then you should not pass that
           descriptor to select() again.  In the above example,  I  close  the
           descriptor  immediately,  and then set it to -1 to prevent it being
           included in a set.

       10. The timeout value  must  be  initialized  with  each  new  call  to
           select(),  since some operating systems modify the structure.  pse-
           lect() however does not modify its timeout structure.

       11. I have heard that the Windows socket layer does not cope  with  OOB
           data  properly.   It also does not cope with select() calls when no
           file descriptors are set at all.  Having no file descriptors set is
           a  useful  way  to  sleep  the process with sub-second precision by
           using the timeout.  (See further on.)

   Usleep Emulation
       On systems that do not have a usleep(3) function, you can call select()
       with a finite timeout and no file descriptors as follows:

           struct timeval tv;
           tv.tv_sec = 0;
           tv.tv_usec = 200000;  /* 0.2 seconds */
           select(0, NULL, NULL, NULL, &tv);

       This is only guaranteed to work on Unix systems, however.

       On success, select() returns the total number of file descriptors still
       present in the file descriptor sets.

       If select() timed out, then the return value will be  zero.   The  file
       descriptors set should be all empty (but may not be on some systems).

       A return value of -1 indicates an error, with errno being set appropri-
       ately.  In the case of an error, the contents of the returned sets  and
       the struct timeout contents are undefined and should not be used.  pse-
       lect() however never modifies ntimeout.

       Generally speaking, all operating systems that  support  sockets,  also
       support  select().  Many types of programs become extremely complicated
       without the use of select().  select() can be used to solve many  prob-
       lems  in  a  portable  and  efficient way that naive programmers try to
       solve in a more complicated manner using threads, forking,  IPCs,  sig-
       nals, memory sharing, and so on.

       The  poll(2) system call has the same functionality as select(), and is
       somewhat more efficient when monitoring sparse  file  descriptor  sets.
       It  is  nowadays  widely  available, but historically was less portable
       than select().

       The Linux-specific epoll(7) API provides  an  interface  that  is  more
       efficient  than  select(2) and poll(2) when monitoring large numbers of
       file descriptors.

       Here is an  example  that  better  demonstrates  the  true  utility  of
       select().   The listing below is a TCP forwarding program that forwards
       from one TCP port to another.

       #include <stdlib.h>
       #include <stdio.h>
       #include <unistd.h>
       #include <sys/time.h>
       #include <sys/types.h>
       #include <string.h>
       #include <signal.h>
       #include <sys/socket.h>
       #include <netinet/in.h>
       #include <arpa/inet.h>
       #include <errno.h>

       static int forward_port;

       #undef max
       #define max(x,y) ((x) > (y) ? (x) : (y))

       static int
       listen_socket(int listen_port)
           struct sockaddr_in a;
           int s;
           int yes;

           if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
               return -1;
           yes = 1;
           if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
                   (char *) &yes, sizeof(yes)) < 0) {
               return -1;
           memset(&a, 0, sizeof(a));
           a.sin_port = htons(listen_port);
           a.sin_family = AF_INET;
           if (bind(s, (struct sockaddr *) &a, sizeof(a)) < 0) {
               return -1;
           printf("accepting connections on port %d\n", listen_port);
           listen(s, 10);
           return s;

       static int
       connect_socket(int connect_port, char *address)
           struct sockaddr_in a;
           int s;

           if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
               return -1;

           memset(&a, 0, sizeof(a));
           a.sin_port = htons(connect_port);
           a.sin_family = AF_INET;

           if (!inet_aton(address, (struct in_addr *) &a.sin_addr.s_addr)) {
               perror("bad IP address format");
               return -1;

           if (connect(s, (struct sockaddr *) &a, sizeof(a)) < 0) {
               shutdown(s, SHUT_RDWR);
               return -1;
           return s;

       #define SHUT_FD1 {                      \
               if (fd1 >= 0) {                 \
                   shutdown(fd1, SHUT_RDWR);   \
                   close(fd1);                 \
                   fd1 = -1;                   \
               }                               \

       #define SHUT_FD2 {                      \
               if (fd2 >= 0) {                 \
                   shutdown(fd2, SHUT_RDWR);   \
                   close(fd2);                 \
                   fd2 = -1;                   \
               }                               \

       #define BUF_SIZE 1024

       main(int argc, char **argv)
           int h;
           int fd1 = -1, fd2 = -1;
           char buf1[BUF_SIZE], buf2[BUF_SIZE];
           int buf1_avail, buf1_written;
           int buf2_avail, buf2_written;

           if (argc != 4) {
                        "Usage\n\tfwd <listen-port> "
                        "<forward-to-port> <forward-to-ip-address>\n");

           signal(SIGPIPE, SIG_IGN);

           forward_port = atoi(argv[2]);

           h = listen_socket(atoi(argv[1]));
           if (h < 0)

           for (;;) {
               int r, nfds = 0;
               fd_set rd, wr, er;
               FD_SET(h, &rd);
               nfds = max(nfds, h);
               if (fd1 > 0 && buf1_avail < BUF_SIZE) {
                   FD_SET(fd1, &rd);
                   nfds = max(nfds, fd1);
               if (fd2 > 0 && buf2_avail < BUF_SIZE) {
                   FD_SET(fd2, &rd);
                   nfds = max(nfds, fd2);
               if (fd1 > 0
                   && buf2_avail - buf2_written > 0) {
                   FD_SET(fd1, &wr);
                   nfds = max(nfds, fd1);
               if (fd2 > 0
                   && buf1_avail - buf1_written > 0) {
                   FD_SET(fd2, &wr);
                   nfds = max(nfds, fd2);
               if (fd1 > 0) {
                   FD_SET(fd1, &er);
                   nfds = max(nfds, fd1);
               if (fd2 > 0) {
                   FD_SET(fd2, &er);
                   nfds = max(nfds, fd2);

               r = select(nfds + 1, &rd, &wr, &er, NULL);

               if (r == -1 && errno == EINTR)
               if (r < 0) {
               if (FD_ISSET(h, &rd)) {
                   unsigned int l;
                   struct sockaddr_in client_address;
                   memset(&client_address, 0, l = sizeof(client_address));
                   r = accept(h, (struct sockaddr *) &client_address, &l);
                   if (r < 0) {
                   } else {
                       buf1_avail = buf1_written = 0;
                       buf2_avail = buf2_written = 0;
                       fd1 = r;
                       fd2 =
                           connect_socket(forward_port, argv[3]);
                       if (fd2 < 0) {
                       } else
                           printf("connect from %s\n",
       /* NB: read oob data before normal reads */
               if (fd1 > 0)
                   if (FD_ISSET(fd1, &er)) {
                       char c;
                       errno = 0;
                       r = recv(fd1, &c, 1, MSG_OOB);
                       if (r < 1) {
                       } else
                           send(fd2, &c, 1, MSG_OOB);
               if (fd2 > 0)
                   if (FD_ISSET(fd2, &er)) {
                       char c;
                       errno = 0;
                       r = recv(fd2, &c, 1, MSG_OOB);
                       if (r < 1) {
                       } else
                           send(fd1, &c, 1, MSG_OOB);
               if (fd1 > 0)
                   if (FD_ISSET(fd1, &rd)) {
                       r =
                           read(fd1, buf1 + buf1_avail,
                                 BUF_SIZE - buf1_avail);
                       if (r < 1) {
                       } else
                           buf1_avail += r;
               if (fd2 > 0)
                   if (FD_ISSET(fd2, &rd)) {
                       r =
                           read(fd2, buf2 + buf2_avail,
                                 BUF_SIZE - buf2_avail);
                       if (r < 1) {
                       } else
                           buf2_avail += r;
               if (fd1 > 0)
                   if (FD_ISSET(fd1, &wr)) {
                       r =
                           write(fd1, buf2 + buf2_written,
                                  buf2_avail - buf2_written);
                       if (r < 1) {
                       } else
                           buf2_written += r;
               if (fd2 > 0)
                   if (FD_ISSET(fd2, &wr)) {
                       r =
                           write(fd2, buf1 + buf1_written,
                                  buf1_avail - buf1_written);
                       if (r < 1) {
                       } else
                           buf1_written += r;
       /* check if write data has caught read data */
               if (buf1_written == buf1_avail)
                   buf1_written = buf1_avail = 0;
               if (buf2_written == buf2_avail)
                   buf2_written = buf2_avail = 0;
       /* one side has closed the connection, keep
          writing to the other side until empty */
               if (fd1 < 0 && buf1_avail - buf1_written == 0) {
               if (fd2 < 0 && buf2_avail - buf2_written == 0) {

       The above program properly  forwards  most  kinds  of  TCP  connections
       including  OOB  signal  data transmitted by telnet servers.  It handles
       the tricky problem of having data flow in  both  directions  simultane-
       ously.   You  might  think  it more efficient to use a fork(2) call and
       devote a thread to each stream.  This  becomes  more  tricky  than  you
       might  suspect.   Another  idea  is  to  set  non-blocking I/O using an
       ioctl(2) call.  This also has its problems because  you  end  up  using
       inefficient timeouts.

       The  program does not handle more than one simultaneous connection at a
       time, although it could easily be extended to do  this  with  a  linked
       list of buffers -- one for each connection.  At the moment, new connec-
       tions cause the current connection to be dropped.

       accept(2), connect(2), ioctl(2), poll(2), read(2), recv(2),  select(2),
       send(2),  sigprocmask(2), write(2), sigaddset(3), sigdelset(3), sigemp-
       tyset(3), sigfillset(3), sigismember(3), epoll(7)

       This page is part of release 3.05 of the Linux  man-pages  project.   A
       description  of  the project, and information about reporting bugs, can
       be found at http://www.kernel.org/doc/man-pages/.

Linux                             2007-12-18                     SELECT_TUT(2)