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.2 2007-11-09 22:08:14 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 static int yaz_poll_select(struct yaz_poll_fd *fds, int num_fds,
  52                            int sec, int nsec)
  53 {
  54     struct timeval tv;
  55     fd_set input, output, except;
  56     int i, r;
  57     int max_fd = 0;
  58
  59     FD_ZERO(&input);
  60     FD_ZERO(&output);
  61     FD_ZERO(&except);
  62
  63     assert(num_fds > 0);
  64     for (i = 0; i < num_fds; i++)
  65     {
  66         enum yaz_poll_mask mask = fds[i].input_mask;
  67         int fd = fds[i].fd;
  68
  69         if (mask & yaz_poll_read)
  70             FD_SET(fd, &input);
  71         if (mask & yaz_poll_write)
  72             FD_SET(fd, &output);
  73         if (mask & yaz_poll_except)
  74             FD_SET(fd, &except);
  75         if (max_fd < fd)
  76             max_fd = fd;
  77     }
  78     tv.tv_sec = sec;
  79     tv.tv_usec = nsec / 1000;
  80
  81     while ((r = select(max_fd+1, &input, &output, &except,
  82                        (sec == -1 ? 0 : &tv))) < 0 && errno == EINTR)
  83     {
  84         ;
  85     }
  86     for (i = 0; i < num_fds; i++)
  87     {
  88         enum yaz_poll_mask mask = 0;
  89         int fd = fds[i].fd;
  90         if (!r)
  91             mask += yaz_poll_timeout;
  92         else
  93         {
  94             if (FD_ISSET(fd, &input))
  95                 mask += yaz_poll_read;
  96             if (FD_ISSET(fd, &output))
  97                 mask += yaz_poll_write;
  98             if (FD_ISSET(fd, &except))
  99                 mask += yaz_poll_except;
 100         }
 101         fds[i].output_mask = mask;
 102     }
 103     return r;
 104 }
 105
 106 #if HAVE_SYS_POLL_H
 107 static int yaz_poll_poll(struct yaz_poll_fd *fds, int num_fds,
 108                          int sec, int nsec)
 109 {
 110     int r;
 111     struct pollfd *pollfds = (struct pollfd *)
 112         xmalloc(num_fds * sizeof *pollfds);
 113     int i;
 114
 115     assert(num_fds > 0);
 116     for (i = 0; i < num_fds; i++)
 117     {
 118         enum yaz_poll_mask mask = fds[i].input_mask;
 119         int fd = fds[i].fd;
 120         short poll_events = 0;
 121
 122         if (mask & yaz_poll_read)
 123             poll_events += POLLIN;
 124         if (mask & yaz_poll_write)
 125             poll_events += POLLOUT;
 126         if (mask & yaz_poll_except)
 127             poll_events += POLLERR;
 128         pollfds[i].fd = fd;
 129         pollfds[i].events = poll_events;
 130         pollfds[i].revents = 0;
 131     }
 132     while ((r = poll(pollfds, num_fds,
 133                      (sec == -1 ? -1 : sec*1000 + nsec/1000000))) < 0
 134            && errno == EINTR)
 135     {
 136         ;
 137     }
 138     if (r >= 0)
 139     {
 140         for (i = 0; i < num_fds; i++)
 141         {
 142             enum yaz_poll_mask mask = 0;
 143             if (!r)
 144                 mask += yaz_poll_timeout;
 145             else
 146             {
 147                 if (pollfds[i].revents & POLLIN)
 148                     mask += yaz_poll_read;
 149                 if (pollfds[i].revents & POLLOUT)
 150                     mask += yaz_poll_write;
 151                 if (pollfds[i].revents & POLLERR)
 152                     mask += yaz_poll_except;
 153             }
 154             fds[i].output_mask = mask;
 155         }
 156     }
 157     xfree(pollfds);
 158     return r;
 159 }
 160 #endif
 161
 162 int yaz_poll(struct yaz_poll_fd *fds, int num_fds, int sec, int nsec)
 163 {
 164 #if YAZ_HAVE_SYS_POLL_H
 165     return yaz_poll_poll(fds, num_fds, sec, nsec);
 166 #else
 167     return yaz_poll_select(fds, num_fds, sec, nsec);
 168 #endif
 169 }
 170
 171 /*
 172  * Local variables:
 173  * c-basic-offset: 4
 174  * indent-tabs-mode: nil
 175  * End:
 176  * vim: shiftwidth=4 tabstop=8 expandtab
 177  */
 178