Wed Aug 18 22:33:54 2010

Asterisk developer's documentation


poll.c

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

Generated on Wed Aug 18 22:33:54 2010 for Asterisk - the Open Source PBX by  doxygen 1.4.7