solenv/unxmacxp/inc/poll.h

   1 // poll.h
   2 // MacOS X does not implement poll().  Therefore, this replacement
   3 // is required.  It uses select().
   4
   5 #ifndef _FAKE_POLL_H
   6 #define _FAKE_POLL_H
   7
   8 #include <sys/errno.h>
   9 #include <string.h>
  10 #include <limits.h>
  11 #undef FD_SETSIZE
  12 #define FD_SETSIZE OPEN_MAX
  13 #include <sys/types.h>
  14 #include <sys/time.h>
  15 #include <unistd.h>
  16 #include <stdlib.h>
  17
  18 typedef struct pollfd {
  19     int fd;                         /* file desc to poll */
  20     short events;                   /* events of interest on fd */
  21     short revents;                  /* events that occurred on fd */
  22 } pollfd_t;
  23
  24
  25 // poll flags
  26 #define POLLIN  0x0001
  27 #define POLLOUT 0x0004
  28 #define POLLERR 0x0008
  29
  30 // synonyms
  31 #define POLLNORM POLLIN
  32 #define POLLPRI POLLIN
  33 #define POLLRDNORM POLLIN
  34 #define POLLRDBAND POLLIN
  35 #define POLLWRNORM POLLOUT
  36 #define POLLWRBAND POLLOUT
  37
  38 // ignored
  39 #define POLLHUP 0x0010
  40 #define POLLNVAL 0x0020
  41
  42 inline int poll(struct pollfd *pollSet, int pollCount, int pollTimeout)
  43 {
  44     struct timeval              tv;
  45     struct timeval              *tvp;
  46     fd_set                      readFDs, writeFDs, exceptFDs;
  47     fd_set                      *readp, *writep, *exceptp;
  48     struct pollfd               *pollEnd, *p;
  49     int                         selected;
  50     int                         result;
  51     int                         maxFD;
  52
  53     if ( !pollSet )
  54     {
  55         pollEnd = NULL;
  56         readp = NULL;
  57         writep = NULL;
  58         exceptp = NULL;
  59         maxFD = 0;
  60     }
  61     else
  62     {
  63         pollEnd = pollSet + pollCount;
  64         readp = &readFDs;
  65         writep = &writeFDs;
  66         exceptp = &exceptFDs;
  67
  68         FD_ZERO(readp);
  69         FD_ZERO(writep);
  70         FD_ZERO(exceptp);
  71
  72         // Find the biggest fd in the poll set
  73         maxFD = 0;
  74         for (p = pollSet; p < pollEnd; p++)
  75         {
  76             if (p->fd > maxFD)
  77                 maxFD = p->fd;
  78         }
  79
  80         if (maxFD >= FD_SETSIZE)
  81         {
  82             // At least one fd is too big
  83             errno = EINVAL;
  84             return -1;
  85         }
  86
  87         // Transcribe flags from the poll set to the fd sets
  88         for (p = pollSet; p < pollEnd; p++)
  89         {
  90             if (p->fd < 0)
  91             {
  92                 // Negative fd checks nothing and always reports zero
  93             }
  94             else
  95             {
  96                 if (p->events & POLLIN)
  97                     FD_SET(p->fd, readp);
  98                 if (p->events & POLLOUT)
  99                     FD_SET(p->fd, writep);
 100                 if (p->events != 0)
 101                     FD_SET(p->fd, exceptp);
 102                 // POLLERR is never set coming in; poll() always reports errors
 103                 // But don't report if we're not listening to anything at all.
 104             }
 105         }
 106     }
 107
 108     // poll timeout is in milliseconds. Convert to struct timeval.
 109     // poll timeout == -1 : wait forever : select timeout of NULL
 110     // poll timeout == 0  : return immediately : select timeout of zero
 111     if (pollTimeout >= 0)
 112     {
 113         tv.tv_sec = pollTimeout / 1000;
 114         tv.tv_usec = (pollTimeout % 1000) * 1000;
 115         tvp = &tv;
 116     }
 117     else
 118     {
 119         tvp = NULL;
 120     }
 121
 122     selected = select(maxFD+1, readp, writep, exceptp, tvp);
 123
 124     if (selected < 0)
 125     {
 126         // Error during select
 127         result = -1;
 128     }
 129     else if (selected > 0)
 130     {
 131         // Select found something
 132         // Transcribe result from fd sets to poll set.
 133         // Also count the number of selected fds. poll returns the
 134         // number of ready fds; select returns the number of bits set.
 135         int polled = 0;
 136         for (p = pollSet; p < pollEnd; p++)
 137         {
 138             p->revents = 0;
 139             if (p->fd < 0) {
 140                 // Negative fd always reports zero
 141             }
 142             else
 143             {
 144                 if ( (p->events & POLLIN) && FD_ISSET(p->fd, readp) )
 145                     p->revents |= POLLIN;
 146                 if ( (p->events & POLLOUT) && FD_ISSET(p->fd, writep) )
 147                     p->revents |= POLLOUT;
 148                 if ( (p->events != 0) && FD_ISSET(p->fd, exceptp) )
 149                     p->revents |= POLLERR;
 150
 151                 if (p->revents)
 152                     polled++;
 153             }
 154         }
 155         result = polled;
 156     }
 157     else
 158     {
 159         // selected == 0, select timed out before anything happened
 160         // Clear all result bits and return zero.
 161         for (p = pollSet; p < pollEnd; p++)
 162             p->revents = 0;
 163
 164         result = 0;
 165     }
 166
 167     return result;
 168 }
 169
 170
 171 #undef FD_SETSIZE
 172
 173 #endif