Thu Apr 28 2011 16:56:48

Asterisk developer's documentation


poll.c

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