os/xserver_poll.c

   1 /*---------------------------------------------------------------------------*\
   2   $Id$
   3
   4   NAME
   5
   6         poll - select(2)-based poll() emulation function for BSD systems.
   7
   8   SYNOPSIS
   9         #include "poll.h"
  10
  11         struct pollfd
  12         {
  13             int     fd;
  14             short   events;
  15             short   revents;
  16         }
  17
  18         int poll (struct pollfd *pArray, unsigned long n_fds, int timeout)
  19
  20   DESCRIPTION
  21
  22         This file, and the accompanying "poll.h", implement the System V
  23         poll(2) system call for BSD systems (which typically do not provide
  24         poll()).  Poll() provides a method for multiplexing input and output
  25         on multiple open file descriptors; in traditional BSD systems, that
  26         capability is provided by select().  While the semantics of select()
  27         differ from those of poll(), poll() can be readily emulated in terms
  28         of select() -- which is how this function is implemented.
  29
  30   REFERENCES
  31         Stevens, W. Richard. Unix Network Programming.  Prentice-Hall, 1990.
  32
  33   NOTES
  34         1. This software requires an ANSI C compiler.
  35
  36   LICENSE
  37
  38   This software is released under the following BSD license, adapted from
  39   http://opensource.org/licenses/bsd-license.php
  40
  41   Copyright (c) 1995-2011, Brian M. Clapper
  42   All rights reserved.
  43
  44   Redistribution and use in source and binary forms, with or without
  45   modification, are permitted provided that the following conditions are met:
  46
  47   * Redistributions of source code must retain the above copyright notice,
  48     this list of conditions and the following disclaimer.
  49
  50   * Redistributions in binary form must reproduce the above copyright
  51     notice, this list of conditions and the following disclaimer in the
  52     documentation and/or other materials provided with the distribution.
  53
  54   * Neither the name of the clapper.org nor the names of its contributors
  55     may be used to endorse or promote products derived from this software
  56     without specific prior written permission.
  57
  58   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  59   IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  60   THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  61   PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
  62   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  63   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  64   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  65   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  66   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  67   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  68   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  69 \*---------------------------------------------------------------------------*/
  70
  71
  72 /*---------------------------------------------------------------------------*\
  73                                  Includes
  74 \*---------------------------------------------------------------------------*/
  75
  76 #include <dix-config.h>
  77
  78 #include <unistd.h>                          /* standard Unix definitions */
  79 #include <sys/types.h>                       /* system types */
  80 #include <sys/time.h>                        /* time definitions */
  81 #include <assert.h>                          /* assertion macros */
  82 #include <string.h>                          /* string functions */
  83
  84 #if defined(WIN32) && !defined(__CYGWIN__)
  85 #include <X11/Xwinsock.h>
  86 #endif
  87
  88 #include "os/xserver_poll.h"
  89
  90 /*---------------------------------------------------------------------------*\
  91                                   Macros
  92 \*---------------------------------------------------------------------------*/
  93
  94 #ifndef MAX
  95 #define MAX(a,b)        ((a) > (b) ? (a) : (b))
  96 #endif
  97
  98 /*---------------------------------------------------------------------------*\
  99                              Private Functions
 100 \*---------------------------------------------------------------------------*/
 101
 102 static int map_poll_spec
 103                         (struct pollfd *pArray,
 104                          nfds_t         n_fds,
 105                           fd_set        *pReadSet,
 106                           fd_set        *pWriteSet,
 107                           fd_set        *pExceptSet)
 108 {
 109     register nfds_t  i;                      /* loop control */
 110     register struct  pollfd *pCur;           /* current array element */
 111     register int     max_fd = -1;            /* return value */
 112
 113     /*
 114        Map the poll() structures into the file descriptor sets required
 115        by select().
 116     */
 117     for (i = 0, pCur = pArray; i < n_fds; i++, pCur++)
 118     {
 119         /* Skip any bad FDs in the array. */
 120
 121         if (pCur->fd < 0)
 122             continue;
 123
 124         if (pCur->events & POLLIN)
 125         {
 126             /* "Input Ready" notification desired. */
 127             FD_SET (pCur->fd, pReadSet);
 128         }
 129
 130         if (pCur->events & POLLOUT)
 131         {
 132             /* "Output Possible" notification desired. */
 133             FD_SET (pCur->fd, pWriteSet);
 134         }
 135
 136         if (pCur->events & POLLPRI)
 137         {
 138             /*
 139                "Exception Occurred" notification desired.  (Exceptions
 140                include out of band data.
 141             */
 142             FD_SET (pCur->fd, pExceptSet);
 143         }
 144
 145         max_fd = MAX (max_fd, pCur->fd);
 146     }
 147
 148     return max_fd;
 149 }
 150
 151 static struct timeval *map_timeout
 152                         (int poll_timeout, struct timeval *pSelTimeout)
 153 {
 154     struct timeval *pResult;
 155
 156     /*
 157        Map the poll() timeout value into a select() timeout.  The possible
 158        values of the poll() timeout value, and their meanings, are:
 159
 160        VALUE    MEANING
 161
 162        -1       wait indefinitely (until signal occurs)
 163         0       return immediately, don't block
 164        >0       wait specified number of milliseconds
 165
 166        select() uses a "struct timeval", which specifies the timeout in
 167        seconds and microseconds, so the milliseconds value has to be mapped
 168        accordingly.
 169     */
 170
 171     assert (pSelTimeout != (struct timeval *) NULL);
 172
 173     switch (poll_timeout)
 174     {
 175         case -1:
 176             /*
 177                A NULL timeout structure tells select() to wait indefinitely.
 178             */
 179             pResult = (struct timeval *) NULL;
 180             break;
 181
 182         case 0:
 183             /*
 184                "Return immediately" (test) is specified by all zeros in
 185                a timeval structure.
 186             */
 187             pSelTimeout->tv_sec  = 0;
 188             pSelTimeout->tv_usec = 0;
 189             pResult = pSelTimeout;
 190             break;
 191
 192         default:
 193             /* Wait the specified number of milliseconds. */
 194             pSelTimeout->tv_sec  = poll_timeout / 1000; /* get seconds */
 195             poll_timeout        %= 1000;                /* remove seconds */
 196             pSelTimeout->tv_usec = poll_timeout * 1000; /* get microseconds */
 197             pResult = pSelTimeout;
 198             break;
 199     }
 200
 201
 202     return pResult;
 203 }
 204
 205 static void map_select_results
 206                          (struct pollfd *pArray,
 207                           unsigned long  n_fds,
 208                           fd_set        *pReadSet,
 209                           fd_set        *pWriteSet,
 210                           fd_set        *pExceptSet)
 211 {
 212     register unsigned long  i;                   /* loop control */
 213     register struct         pollfd *pCur;        /* current array element */
 214
 215     for (i = 0, pCur = pArray; i < n_fds; i++, pCur++)
 216     {
 217         /* Skip any bad FDs in the array. */
 218
 219         if (pCur->fd < 0)
 220             continue;
 221
 222         /* Exception events take priority over input events. */
 223
 224         pCur->revents = 0;
 225         if (FD_ISSET (pCur->fd, pExceptSet))
 226             pCur->revents |= POLLPRI;
 227
 228         else if (FD_ISSET (pCur->fd, pReadSet))
 229             pCur->revents |= POLLIN;
 230
 231         if (FD_ISSET (pCur->fd, pWriteSet))
 232             pCur->revents |= POLLOUT;
 233     }
 234
 235     return;
 236 }
 237
 238 /*---------------------------------------------------------------------------*\
 239                              Public Functions
 240 \*---------------------------------------------------------------------------*/
 241
 242 int xserver_poll
 243         (struct pollfd *pArray, unsigned long n_fds, int timeout)
 244 {
 245     fd_set  read_descs;                          /* input file descs */
 246     fd_set  write_descs;                         /* output file descs */
 247     fd_set  except_descs;                        /* exception descs */
 248     struct  timeval stime;                       /* select() timeout value */
 249     int     ready_descriptors;                   /* function result */
 250     int     max_fd;                              /* maximum fd value */
 251     struct  timeval *pTimeout;                   /* actually passed */
 252
 253     FD_ZERO (&read_descs);
 254     FD_ZERO (&write_descs);
 255     FD_ZERO (&except_descs);
 256
 257     assert (pArray != (struct pollfd *) NULL);
 258
 259     /* Map the poll() file descriptor list in the select() data structures. */
 260
 261     max_fd = map_poll_spec (pArray, n_fds,
 262                             &read_descs, &write_descs, &except_descs);
 263
 264     /* Map the poll() timeout value in the select() timeout structure. */
 265
 266     pTimeout = map_timeout (timeout, &stime);
 267
 268     /* Make the select() call. */
 269
 270     ready_descriptors = select (max_fd + 1, &read_descs, &write_descs,
 271                                 &except_descs, pTimeout);
 272
 273     if (ready_descriptors >= 0)
 274     {
 275         map_select_results (pArray, n_fds,
 276                             &read_descs, &write_descs, &except_descs);
 277     }
 278
 279     return ready_descriptors;
 280 }