poll_emu.c
Go to the documentation of this file.
00001 /*---------------------------------------------------------------------------*\
00002   $Id: poll.c,v 1.4 2003/01/01 19:02:29 bmc Exp $
00003 
00004   NAME
00005 
00006         poll - select(2)-based poll() emulation function for BSD systems.
00007 
00008   SYNOPSIS
00009         #include "poll.h"
00010 
00011         struct pollfd
00012         {
00013             int     fd;
00014             short   events;
00015             short   revents;
00016         }
00017 
00018         int poll (struct pollfd *pArray, unsigned long n_fds, int timeout)
00019 
00020   DESCRIPTION
00021 
00022         This file, and the accompanying "poll.h", implement the System V
00023         poll(2) system call for BSD systems (which typically do not provide
00024         poll()).  Poll() provides a method for multiplexing input and output
00025         on multiple open file descriptors; in traditional BSD systems, that
00026         capability is provided by select().  While the semantics of select()
00027         differ from those of poll(), poll() can be readily emulated in terms
00028         of select() -- which is how this function is implemented.
00029 
00030   REFERENCES
00031         Stevens, W. Richard. Unix Network Programming.  Prentice-Hall, 1990.
00032 
00033   NOTES
00034         1. This software requires an ANSI C compiler.
00035 
00036   LICENSE
00037 
00038         This software is released under the following license:
00039 
00040                 Copyright (c) 1995-2002 Brian M. Clapper
00041                 All rights reserved.
00042 
00043                 Redistribution and use in source and binary forms are
00044                 permitted provided that: (1) source distributions retain
00045                 this entire copyright notice and comment; (2) modifications
00046                 made to the software are prominently mentioned, and a copy
00047                 of the original software (or a pointer to its location) are
00048                 included; and (3) distributions including binaries display
00049                 the following acknowledgement: "This product includes
00050                 software developed by Brian M. Clapper <bmc@clapper.org>"
00051                 in the documentation or other materials provided with the
00052                 distribution. The name of the author may not be used to
00053                 endorse or promote products derived from this software
00054                 without specific prior written permission.
00055 
00056                 THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS
00057                 OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE
00058                 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
00059                 PARTICULAR PURPOSE.
00060 
00061         Effectively, this means you can do what you want with the software
00062         except remove this notice or take advantage of the author's name.
00063         If you modify the software and redistribute your modified version,
00064         you must indicate that your version is a modification of the
00065         original, and you must provide either a pointer to or a copy of the
00066         original.
00067 \*---------------------------------------------------------------------------*/
00068 
00069 /*
00070 HISTORY
00071 
00072 ** 2008-02-15 Antoine Beyeler <abeyeler at ab-ware dot com>
00073 Trivial modification to change call name (poll() -> poll_emu()).
00074 
00075 */
00076 
00077 
00078 
00079 /*---------------------------------------------------------------------------*\
00080                                  Includes
00081 \*---------------------------------------------------------------------------*/
00082 
00083 #include <unistd.h>                          /* standard Unix definitions */
00084 #include <sys/types.h>                       /* system types */
00085 #include <sys/time.h>                        /* time definitions */
00086 #include <assert.h>                          /* assertion macros */
00087 #include <string.h>                          /* string functions */
00088 #include "poll_emu.h"                        /* this package */
00089 
00090 
00091 /*---------------------------------------------------------------------------*\
00092                                   Macros
00093 \*---------------------------------------------------------------------------*/
00094 
00095 #ifndef MAX
00096 #define MAX(a,b)        ((a) > (b) ? (a) : (b))
00097 #endif
00098 
00099 
00100 /*---------------------------------------------------------------------------*\
00101                              Private Functions
00102 \*---------------------------------------------------------------------------*/
00103 
00104 static int map_poll_spec
00105 #if __STDC__ > 0
00106                         (struct pollfd *pArray,
00107                           unsigned long  n_fds,
00108                           fd_set        *pReadSet,
00109                           fd_set        *pWriteSet,
00110                           fd_set        *pExceptSet)
00111 #else
00112                          (pArray, n_fds, pReadSet, pWriteSet, pExceptSet)
00113                           struct pollfd *pArray;
00114                           unsigned long  n_fds;
00115                           fd_set        *pReadSet;
00116                           fd_set        *pWriteSet;
00117                           fd_set        *pExceptSet;
00118 #endif
00119 {
00120     register unsigned long  i;                   /* loop control */
00121     register struct         pollfd *pCur;        /* current array element */
00122     register int            max_fd = -1;         /* return value */
00123 
00124     /*
00125        Map the poll() structures into the file descriptor sets required
00126        by select().
00127     */
00128     for (i = 0, pCur = pArray; i < n_fds; i++, pCur++)
00129     {
00130         /* Skip any bad FDs in the array. */
00131 
00132         if (pCur->fd < 0)
00133             continue;
00134 
00135         if (pCur->events & POLLIN)
00136         {
00137             /* "Input Ready" notification desired. */
00138             FD_SET (pCur->fd, pReadSet);
00139         }
00140 
00141         if (pCur->events & POLLOUT)
00142         {
00143             /* "Output Possible" notification desired. */
00144             FD_SET (pCur->fd, pWriteSet);
00145         }
00146 
00147         if (pCur->events & POLLPRI)
00148         {
00149             /*
00150                "Exception Occurred" notification desired.  (Exceptions
00151                include out of band data.
00152             */
00153             FD_SET (pCur->fd, pExceptSet);
00154         }
00155 
00156         max_fd = MAX (max_fd, pCur->fd);
00157     }
00158 
00159     return max_fd;
00160 }
00161 
00162 static struct timeval *map_timeout
00163 #if __STDC__ > 0
00164                         (int poll_timeout, struct timeval *pSelTimeout)
00165 #else
00166                         (poll_timeout, pSelTimeout)
00167                          int             poll_timeout;
00168                          struct timeval *pSelTimeout;
00169 #endif
00170 {
00171     struct timeval *pResult;
00172 
00173     /*
00174        Map the poll() timeout value into a select() timeout.  The possible
00175        values of the poll() timeout value, and their meanings, are:
00176 
00177        VALUE    MEANING
00178 
00179        -1       wait indefinitely (until signal occurs)
00180         0       return immediately, don't block
00181        >0       wait specified number of milliseconds
00182 
00183        select() uses a "struct timeval", which specifies the timeout in
00184        seconds and microseconds, so the milliseconds value has to be mapped
00185        accordingly.
00186     */
00187 
00188     assert (pSelTimeout != (struct timeval *) NULL);
00189 
00190     switch (poll_timeout)
00191     {
00192         case -1:
00193             /*
00194                A NULL timeout structure tells select() to wait indefinitely.
00195             */
00196             pResult = (struct timeval *) NULL;
00197             break;
00198 
00199         case 0:
00200             /*
00201                "Return immediately" (test) is specified by all zeros in
00202                a timeval structure.
00203             */
00204             pSelTimeout->tv_sec  = 0;
00205             pSelTimeout->tv_usec = 0;
00206             pResult = pSelTimeout;
00207             break;
00208 
00209         default:
00210             /* Wait the specified number of milliseconds. */
00211             pSelTimeout->tv_sec  = poll_timeout / 1000; /* get seconds */
00212             poll_timeout        %= 1000;                /* remove seconds */
00213             pSelTimeout->tv_usec = poll_timeout * 1000; /* get microseconds */
00214             pResult = pSelTimeout;
00215             break;
00216     }
00217 
00218 
00219     return pResult;
00220 }
00221 
00222 static void map_select_results
00223 #if __STDC__ > 0
00224                          (struct pollfd *pArray,
00225                           unsigned long  n_fds,
00226                           fd_set        *pReadSet,
00227                           fd_set        *pWriteSet,
00228                           fd_set        *pExceptSet)
00229 #else
00230                          (pArray, n_fds, pReadSet, pWriteSet, pExceptSet)
00231                           struct pollfd *pArray;
00232                           unsigned long  n_fds;
00233                           fd_set        *pReadSet;
00234                           fd_set        *pWriteSet;
00235                           fd_set        *pExceptSet;
00236 #endif
00237 {
00238     register unsigned long  i;                   /* loop control */
00239     register struct         pollfd *pCur;        /* current array element */
00240 
00241     for (i = 0, pCur = pArray; i < n_fds; i++, pCur++)
00242     {
00243         /* Skip any bad FDs in the array. */
00244 
00245         if (pCur->fd < 0)
00246             continue;
00247 
00248         /* Exception events take priority over input events. */
00249 
00250         pCur->revents = 0;
00251         if (FD_ISSET (pCur->fd, pExceptSet))
00252             pCur->revents |= POLLPRI;
00253 
00254         else if (FD_ISSET (pCur->fd, pReadSet))
00255             pCur->revents |= POLLIN;
00256 
00257         if (FD_ISSET (pCur->fd, pWriteSet))
00258             pCur->revents |= POLLOUT;
00259     }
00260 
00261     return;
00262 }
00263 
00264 /*---------------------------------------------------------------------------*\
00265                              Public Functions
00266 \*---------------------------------------------------------------------------*/
00267 
00268 int poll_emu
00269 
00270 #if __STDC__ > 0
00271         (struct pollfd *pArray, unsigned long n_fds, int timeout)
00272 #else
00273         (pArray, n_fds, timeout)
00274          struct        pollfd *pArray;
00275          unsigned long n_fds;
00276          int           timeout;
00277 #endif
00278 
00279 {
00280     fd_set  read_descs;                          /* input file descs */
00281     fd_set  write_descs;                         /* output file descs */
00282     fd_set  except_descs;                        /* exception descs */
00283     struct  timeval stime;                       /* select() timeout value */
00284     int     ready_descriptors;                   /* function result */
00285     int     max_fd;                              /* maximum fd value */
00286     struct  timeval *pTimeout;                   /* actually passed */
00287 
00288     FD_ZERO (&read_descs);
00289     FD_ZERO (&write_descs);
00290     FD_ZERO (&except_descs);
00291 
00292     assert (pArray != (struct pollfd *) NULL);
00293 
00294     /* Map the poll() file descriptor list in the select() data structures. */
00295 
00296     max_fd = map_poll_spec (pArray, n_fds,
00297                             &read_descs, &write_descs, &except_descs);
00298 
00299     /* Map the poll() timeout value in the select() timeout structure. */
00300 
00301     pTimeout = map_timeout (timeout, &stime);
00302 
00303     /* Make the select() call. */
00304 
00305     ready_descriptors = select (max_fd + 1, &read_descs, &write_descs,
00306                                 &except_descs, pTimeout);
00307 
00308     if (ready_descriptors >= 0)
00309     {
00310         map_select_results (pArray, n_fds,
00311                             &read_descs, &write_descs, &except_descs);
00312     }
00313 
00314     return ready_descriptors;
00315 }


dashel
Author(s): Stéphane Magnenat
autogenerated on Thu Jan 2 2014 11:17:11