src/poll.c

   1 /*
   2  * Copyright (C) 1995-2007, Index Data ApS
   3  * See the file LICENSE for details.
   4  *
   5  * $Id: poll.c,v 1.1 2007-11-09 16:46:43 adam Exp $
   6  */
   7 /**
   8  * \file
   9  * \brief Select, poll wrapper
  10  */
  11
  12 #include <assert.h>
  13 #include <string.h>
  14 #include <errno.h>
  15
  16 #include <yaz/log.h>
  17 #include <yaz/xmalloc.h>
  18 #include <yaz/poll.h>
  19
  20 #if HAVE_SYS_TYPES_H
  21 #include <sys/types.h>
  22 #endif
  23 #if HAVE_SYS_TIME_H
  24 #include <sys/time.h>
  25 #endif
  26 #if HAVE_SYS_POLL_H
  27 #include <sys/poll.h>
  28 #endif
  29 #if HAVE_SYS_SELECT_H
  30 #include <sys/select.h>
  31 #endif
  32 #ifdef WIN32
  33 #if FD_SETSIZE < 512
  34 #define FD_SETSIZE 512
  35 #endif
  36 #include <winsock.h>
  37 #endif
  38
  39 /*
  40   Note that yaz_poll_select is limited as to how many file
  41   descriptors it can multiplex due to its use of select() which in
  42   turn uses the statically defined fd_set type to be a bitmap of the
  43   file descriptors to check.  On Ubuntu 6.06 (and almost certainly on
  44   Debian, and probably on all Linuxes, and maybe all Unixes) this is
  45   by default set to 1024 (though it may be possible to override this
  46   using a #define before including <sys/select.h> -- I've not tried
  47   this).  1024 file descriptors is a lot, but not enough in all
  48   cases, e.g. when running IRSpy on a large target database.  So you
  49   should ensure that YAZ uses ZOOM_yaz_poll_poll() when possible.
  50 */
  51 int yaz_poll_select(struct yaz_poll_fd *fds, int num_fds, int timeout)
  52 {
  53     struct timeval tv;
  54     fd_set input, output, except;
  55     int i, r;
  56     int max_fd = 0;
  57
  58     FD_ZERO(&input);
  59     FD_ZERO(&output);
  60     FD_ZERO(&except);
  61
  62     assert(num_fds > 0);
  63     for (i = 0; i < num_fds; i++)
  64     {
  65         enum yaz_poll_mask mask = fds[i].input_mask;
  66         int fd = fds[i].fd;
  67
  68         if (mask & yaz_poll_read)
  69             FD_SET(fd, &input);
  70         if (mask & yaz_poll_write)
  71             FD_SET(fd, &output);
  72         if (mask & yaz_poll_except)
  73             FD_SET(fd, &except);
  74         if (max_fd < fd)
  75             max_fd = fd;
  76     }
  77     tv.tv_sec = timeout;
  78     tv.tv_usec = 0;
  79
  80     while ((r = select(max_fd+1, &input, &output, &except,
  81                        (timeout == -1 ? 0 : &tv))) < 0 && errno == EINTR)
  82     {
  83         ;
  84     }
  85     for (i = 0; i < num_fds; i++)
  86     {
  87         enum yaz_poll_mask mask = 0;
  88         int fd = fds[i].fd;
  89         if (!r)
  90             mask += yaz_poll_timeout;
  91         else
  92         {
  93             if (FD_ISSET(fd, &input))
  94                 mask += yaz_poll_read;
  95             if (FD_ISSET(fd, &output))
  96                 mask += yaz_poll_write;
  97             if (FD_ISSET(fd, &except))
  98                 mask += yaz_poll_except;
  99         }
 100         fds[i].output_mask = mask;
 101     }
 102     return r;
 103 }
 104
 105 #if HAVE_SYS_POLL_H
 106 int yaz_poll_poll(struct yaz_poll_fd *fds, int num_fds, int timeout)
 107 {
 108     int r;
 109     struct pollfd *pollfds = (struct pollfd *)
 110         xmalloc(num_fds * sizeof *pollfds);
 111     int i;
 112
 113     assert(num_fds > 0);
 114     for (i = 0; i < num_fds; i++)
 115     {
 116         enum yaz_poll_mask mask = fds[i].input_mask;
 117         int fd = fds[i].fd;
 118         short poll_events = 0;
 119
 120         if (mask & yaz_poll_read)
 121             poll_events += POLLIN;
 122         if (mask & yaz_poll_write)
 123             poll_events += POLLOUT;
 124         if (mask & yaz_poll_except)
 125             poll_events += POLLERR;
 126         pollfds[i].fd = fd;
 127         pollfds[i].events = poll_events;
 128         pollfds[i].revents = 0;
 129     }
 130     while ((r = poll(pollfds, num_fds,
 131                      (timeout == -1 ? -1 : timeout * 1000))) < 0
 132            && errno == EINTR)
 133     {
 134         ;
 135     }
 136     if (r >= 0)
 137     {
 138         for (i = 0; i < num_fds; i++)
 139         {
 140             enum yaz_poll_mask mask = 0;
 141             if (!r)
 142                 mask += yaz_poll_timeout;
 143             else
 144             {
 145                 if (pollfds[i].revents & POLLIN)
 146                     mask += yaz_poll_read;
 147                 if (pollfds[i].revents & POLLOUT)
 148                     mask += yaz_poll_write;
 149                 if (pollfds[i].revents & POLLERR)
 150                     mask += yaz_poll_except;
 151             }
 152             fds[i].output_mask = mask;
 153         }
 154     }
 155     xfree(pollfds);
 156     return r;
 157 }
 158 #endif
 159
 160 int yaz_poll(struct yaz_poll_fd *fds, int num_fds, int timeout)
 161 {
 162 #if YAZ_HAVE_SYS_POLL_H
 163     return yaz_poll_poll(fds, num_fds, timeout);
 164 #else
 165     return yaz_poll_select(fds, num_fds, timeout);
 166 #endif
 167 }
 168
 169 /*
 170  * Local variables:
 171  * c-basic-offset: 4
 172  * indent-tabs-mode: nil
 173  * End:
 174  * vim: shiftwidth=4 tabstop=8 expandtab
 175  */
 176