Fri Jun 19 12:09:50 2009

Asterisk developer's documentation


poll.c

Go to the documentation of this file.
00001 /*---------------------------------------------------------------------------*\
00002   $Id: poll.c 182946 2009-03-18 14:32:47Z russell $
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 /*---------------------------------------------------------------------------*\
00071              Includes
00072 \*---------------------------------------------------------------------------*/
00073 
00074 #include "asterisk.h"
00075 
00076 #include <unistd.h>             /* standard Unix definitions */
00077 #include <sys/types.h>                       /* system types */
00078 #include <sys/time.h>                        /* time definitions */
00079 #include <assert.h>                          /* assertion macros */
00080 #include <string.h>                          /* string functions */
00081 
00082 #include "asterisk/poll-compat.h"                            /* this package */
00083 
00084 #ifdef AST_POLL_COMPAT
00085 
00086 /*---------------------------------------------------------------------------*\
00087               Macros
00088 \*---------------------------------------------------------------------------*/
00089 
00090 #ifndef MAX
00091 #define MAX(a,b)  ((a) > (b) ? (a) : (b))
00092 #endif
00093 
00094 /*---------------------------------------------------------------------------*\
00095               Private Functions
00096 \*---------------------------------------------------------------------------*/
00097 
00098 static int map_poll_spec
00099 #if __STDC__ > 0
00100          (struct pollfd *pArray,
00101            unsigned long  n_fds,
00102            fd_set        *pReadSet,
00103            fd_set        *pWriteSet,
00104            fd_set        *pExceptSet)
00105 #else
00106           (pArray, n_fds, pReadSet, pWriteSet, pExceptSet)
00107            struct pollfd *pArray;
00108            unsigned long  n_fds;
00109            fd_set        *pReadSet;
00110            fd_set        *pWriteSet;
00111            fd_set        *pExceptSet;
00112 #endif
00113 {
00114    register unsigned long  i;                   /* loop control */
00115    register struct       pollfd *pCur;        /* current array element */
00116    register int       max_fd = -1;         /* return value */
00117 
00118    /*!\note
00119     * Map the poll() structures into the file descriptor sets required
00120     * by select().
00121     */
00122    for (i = 0, pCur = pArray; i < n_fds; i++, pCur++) {
00123       /* Skip any bad FDs in the array. */
00124 
00125       if (pCur->fd < 0)
00126          continue;
00127 
00128       if (pCur->events & POLLIN) {
00129          /* "Input Ready" notification desired. */
00130          FD_SET(pCur->fd, pReadSet);
00131       }
00132 
00133       if (pCur->events & POLLOUT) {
00134          /* "Output Possible" notification desired. */
00135          FD_SET(pCur->fd, pWriteSet);
00136       }
00137 
00138       if (pCur->events & POLLPRI) {
00139          /*!\note
00140           * "Exception Occurred" notification desired.  (Exceptions
00141           * include out of band data.)
00142           */
00143          FD_SET(pCur->fd, pExceptSet);
00144       }
00145 
00146       max_fd = MAX(max_fd, pCur->fd);
00147    }
00148 
00149    return max_fd;
00150 }
00151 
00152 static struct timeval *map_timeout
00153 #if __STDC__ > 0
00154          (int poll_timeout, struct timeval *pSelTimeout)
00155 #else
00156          (poll_timeout, pSelTimeout)
00157           int             poll_timeout;
00158           struct timeval *pSelTimeout;
00159 #endif
00160 {
00161    struct timeval *pResult;
00162 
00163    /*!\note
00164     * Map the poll() timeout value into a select() timeout.  The possible
00165     * values of the poll() timeout value, and their meanings, are:
00166     *
00167     * VALUE MEANING
00168     *
00169     * -1 wait indefinitely (until signal occurs)
00170     *  0 return immediately, don't block
00171     * >0 wait specified number of milliseconds
00172     *
00173     * select() uses a "struct timeval", which specifies the timeout in
00174     * seconds and microseconds, so the milliseconds value has to be mapped
00175     * accordingly.
00176     */
00177 
00178    assert(pSelTimeout != (struct timeval *) NULL);
00179 
00180    switch (poll_timeout) {
00181    case -1:
00182       /*
00183        * A NULL timeout structure tells select() to wait indefinitely.
00184        */
00185       pResult = (struct timeval *) NULL;
00186       break;
00187 
00188    case 0:
00189       /*
00190        * "Return immediately" (test) is specified by all zeros in
00191        * a timeval structure.
00192        */
00193       pSelTimeout->tv_sec  = 0;
00194       pSelTimeout->tv_usec = 0;
00195       pResult = pSelTimeout;
00196       break;
00197 
00198    default:
00199       /* Wait the specified number of milliseconds. */
00200       pSelTimeout->tv_sec  = poll_timeout / 1000; /* get seconds */
00201       poll_timeout        %= 1000;                /* remove seconds */
00202       pSelTimeout->tv_usec = poll_timeout * 1000; /* get microseconds */
00203       pResult = pSelTimeout;
00204       break;
00205    }
00206 
00207    return pResult;
00208 }
00209 
00210 static void map_select_results
00211 #if __STDC__ > 0
00212           (struct pollfd *pArray,
00213            unsigned long  n_fds,
00214            fd_set        *pReadSet,
00215            fd_set        *pWriteSet,
00216            fd_set        *pExceptSet)
00217 #else
00218           (pArray, n_fds, pReadSet, pWriteSet, pExceptSet)
00219            struct pollfd *pArray;
00220            unsigned long  n_fds;
00221            fd_set        *pReadSet;
00222            fd_set        *pWriteSet;
00223            fd_set        *pExceptSet;
00224 #endif
00225 {
00226    register unsigned long  i;                   /* loop control */
00227    register struct       pollfd *pCur;        /* current array element */
00228 
00229    for (i = 0, pCur = pArray; i < n_fds; i++, pCur++) {
00230       /* Skip any bad FDs in the array. */
00231 
00232       if (pCur->fd < 0) {
00233          continue;
00234       }
00235 
00236       /* Exception events take priority over input events. */
00237 
00238       pCur->revents = 0;
00239       if (FD_ISSET (pCur->fd, pExceptSet)) {
00240          pCur->revents |= POLLPRI;
00241       } else if (FD_ISSET (pCur->fd, pReadSet)) {
00242          pCur->revents |= POLLIN;
00243       }
00244 
00245       if (FD_ISSET (pCur->fd, pWriteSet)) {
00246          pCur->revents |= POLLOUT;
00247       }
00248    }
00249 
00250    return;
00251 }
00252 
00253 /*---------------------------------------------------------------------------*\
00254               Public Functions
00255 \*---------------------------------------------------------------------------*/
00256 
00257 int ast_internal_poll(struct pollfd *pArray, unsigned long n_fds, int timeout)
00258 {
00259    fd_set  read_descs;                          /* input file descs */
00260    fd_set  write_descs;                         /* output file descs */
00261    fd_set  except_descs;                        /* exception descs */
00262    struct  timeval stime;                       /* select() timeout value */
00263    int       ready_descriptors;                   /* function result */
00264    int       max_fd = 0;                          /* maximum fd value */
00265    struct  timeval *pTimeout;                   /* actually passed */
00266 
00267    FD_ZERO (&read_descs);
00268    FD_ZERO (&write_descs);
00269    FD_ZERO (&except_descs);
00270 
00271    /* Map the poll() file descriptor list in the select() data structures. */
00272 
00273    if (pArray) {
00274       max_fd = map_poll_spec (pArray, n_fds,
00275             &read_descs, &write_descs, &except_descs);
00276    }
00277 
00278    /* Map the poll() timeout value in the select() timeout structure. */
00279    pTimeout = map_timeout(timeout, &stime);
00280 
00281    /* Make the select() call. */
00282    ready_descriptors = select(max_fd + 1, &read_descs, &write_descs,
00283             &except_descs, pTimeout);
00284 
00285    if (ready_descriptors >= 0) {
00286       map_select_results(pArray, n_fds, &read_descs, &write_descs, &except_descs);
00287    }
00288 
00289    return ready_descriptors;
00290 }
00291 
00292 #endif /* AST_POLL_COMPAT */

Generated on Fri Jun 19 12:09:50 2009 for Asterisk - the Open Source PBX by  doxygen 1.4.7