glib/gpoll.c

   1 /* GLIB - Library of useful routines for C programming
   2  * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * gpoll.c: poll(2) abstraction
   5  * Copyright 1998 Owen Taylor
   6  * Copyright 2008 Red Hat, Inc.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 /*
  25  * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
  26  * file for a list of people on the GLib Team.  See the ChangeLog
  27  * files for a list of changes.  These files are distributed with
  28  * GLib at ftp://ftp.gtk.org/pub/gtk/.
  29  */
  30
  31 /*
  32  * MT safe
  33  */
  34
  35 #include "config.h"
  36 #include "glibconfig.h"
  37 #include "giochannel.h"
  38
  39 /* Uncomment the next line (and the corresponding line in gmain.c) to
  40  * enable debugging printouts if the environment variable
  41  * G_MAIN_POLL_DEBUG is set to some value.
  42  */
  43 /* #define G_MAIN_POLL_DEBUG */
  44
  45 #ifdef _WIN32
  46 /* Always enable debugging printout on Windows, as it is more often
  47  * needed there...
  48  */
  49 #define G_MAIN_POLL_DEBUG
  50 #endif
  51
  52 #include <sys/types.h>
  53 #include <time.h>
  54 #include <stdlib.h>
  55 #ifdef HAVE_SYS_TIME_H
  56 #include <sys/time.h>
  57 #endif /* HAVE_SYS_TIME_H */
  58 #ifdef GLIB_HAVE_SYS_POLL_H
  59 #  include <sys/poll.h>
  60 #  undef events  /* AIX 4.1.5 & 4.3.2 define this for SVR3,4 compatibility */
  61 #  undef revents /* AIX 4.1.5 & 4.3.2 define this for SVR3,4 compatibility */
  62
  63 /* The poll() emulation on OS/X doesn't handle fds=NULL, nfds=0,
  64  * so we prefer our own poll emulation.
  65  */
  66 #if defined(_POLL_EMUL_H_) || defined(BROKEN_POLL)
  67 #undef HAVE_POLL
  68 #endif
  69
  70 #endif /* GLIB_HAVE_SYS_POLL_H */
  71 #ifdef HAVE_UNISTD_H
  72 #include <unistd.h>
  73 #endif /* HAVE_UNISTD_H */
  74 #include <errno.h>
  75
  76 #ifdef G_OS_WIN32
  77 #define STRICT
  78 #include <windows.h>
  79 #endif /* G_OS_WIN32 */
  80
  81 #include "gpoll.h"
  82
  83 #ifdef G_OS_WIN32
  84 #include "gprintf.h"
  85 #endif
  86
  87 #ifdef G_MAIN_POLL_DEBUG
  88 extern gboolean _g_main_poll_debug;
  89 #endif
  90
  91 #ifdef HAVE_POLL
  92 /* SunOS has poll, but doesn't provide a prototype. */
  93 #  if defined (sun) && !defined (__SVR4)
  94 extern gint poll (struct pollfd *fds, guint nfsd, gint timeout);
  95 #  endif  /* !sun */
  96
  97 /**
  98  * g_poll:
  99  * @fds: file descriptors to poll
 100  * @nfds: the number of file descriptors in @fds
 101  * @timeout: amount of time to wait, in milliseconds, or -1 to wait forever
 102  *
 103  * Polls @fds, as with the poll() system call, but portably. (On
 104  * systems that don't have poll(), it is emulated using select().)
 105  * This is used internally by #GMainContext, but it can be called
 106  * directly if you need to block until a file descriptor is ready, but
 107  * don't want to run the full main loop.
 108  *
 109  * Each element of @fds is a #GPollFD describing a single file
 110  * descriptor to poll. The %fd field indicates the file descriptor,
 111  * and the %events field indicates the events to poll for. On return,
 112  * the %revents fields will be filled with the events that actually
 113  * occurred.
 114  *
 115  * On POSIX systems, the file descriptors in @fds can be any sort of
 116  * file descriptor, but the situation is much more complicated on
 117  * Windows. If you need to use g_poll() in code that has to run on
 118  * Windows, the easiest solution is to construct all of your
 119  * #GPollFD<!-- -->s with g_io_channel_win32_make_pollfd().
 120  *
 121  * Return value: the number of entries in @fds whose %revents fields
 122  * were filled in, or 0 if the operation timed out, or -1 on error or
 123  * if the call was interrupted.
 124  *
 125  * Since: 2.20
 126  **/
 127 gint
 128 g_poll (GPollFD *fds,
 129         guint    nfds,
 130         gint     timeout)
 131 {
 132   return poll ((struct pollfd *)fds, nfds, timeout);
 133 }
 134
 135 #else   /* !HAVE_POLL */
 136
 137 #ifdef G_OS_WIN32
 138
 139 static int
 140 poll_rest (gboolean  poll_msgs,
 141            HANDLE   *handles,
 142            gint      nhandles,
 143            GPollFD  *fds,
 144            guint     nfds,
 145            gint      timeout)
 146 {
 147   DWORD ready;
 148   GPollFD *f;
 149   int recursed_result;
 150
 151   if (poll_msgs)
 152     {
 153       /* Wait for either messages or handles
 154        * -> Use MsgWaitForMultipleObjectsEx
 155        */
 156       if (_g_main_poll_debug)
 157         g_print ("  MsgWaitForMultipleObjectsEx(%d, %d)\n", nhandles, timeout);
 158
 159       ready = MsgWaitForMultipleObjectsEx (nhandles, handles, timeout,
 160                                            QS_ALLINPUT, MWMO_ALERTABLE);
 161
 162       if (ready == WAIT_FAILED)
 163         {
 164           gchar *emsg = g_win32_error_message (GetLastError ());
 165           g_warning ("MsgWaitForMultipleObjectsEx failed: %s", emsg);
 166           g_free (emsg);
 167         }
 168     }
 169   else if (nhandles == 0)
 170     {
 171       /* No handles to wait for, just the timeout */
 172       if (timeout == INFINITE)
 173         ready = WAIT_FAILED;
 174       else
 175         {
 176           SleepEx (timeout, TRUE);
 177           ready = WAIT_TIMEOUT;
 178         }
 179     }
 180   else
 181     {
 182       /* Wait for just handles
 183        * -> Use WaitForMultipleObjectsEx
 184        */
 185       if (_g_main_poll_debug)
 186         g_print ("  WaitForMultipleObjectsEx(%d, %d)\n", nhandles, timeout);
 187
 188       ready = WaitForMultipleObjectsEx (nhandles, handles, FALSE, timeout, TRUE);
 189       if (ready == WAIT_FAILED)
 190         {
 191           gchar *emsg = g_win32_error_message (GetLastError ());
 192           g_warning ("WaitForMultipleObjectsEx failed: %s", emsg);
 193           g_free (emsg);
 194         }
 195     }
 196
 197   if (_g_main_poll_debug)
 198     g_print ("  wait returns %ld%s\n",
 199              ready,
 200              (ready == WAIT_FAILED ? " (WAIT_FAILED)" :
 201               (ready == WAIT_TIMEOUT ? " (WAIT_TIMEOUT)" :
 202                (poll_msgs && ready == WAIT_OBJECT_0 + nhandles ? " (msg)" : ""))));
 203
 204   if (ready == WAIT_FAILED)
 205     return -1;
 206   else if (ready == WAIT_TIMEOUT ||
 207            ready == WAIT_IO_COMPLETION)
 208     return 0;
 209   else if (poll_msgs && ready == WAIT_OBJECT_0 + nhandles)
 210     {
 211       for (f = fds; f < &fds[nfds]; ++f)
 212         if (f->fd == G_WIN32_MSG_HANDLE && f->events & G_IO_IN)
 213           f->revents |= G_IO_IN;
 214
 215       /* If we have a timeout, or no handles to poll, be satisfied
 216        * with just noticing we have messages waiting.
 217        */
 218       if (timeout != 0 || nhandles == 0)
 219         return 1;
 220
 221       /* If no timeout and handles to poll, recurse to poll them,
 222        * too.
 223        */
 224       recursed_result = poll_rest (FALSE, handles, nhandles, fds, nfds, 0);
 225       return (recursed_result == -1) ? -1 : 1 + recursed_result;
 226     }
 227   else if (ready >= WAIT_OBJECT_0 && ready < WAIT_OBJECT_0 + nhandles)
 228     {
 229       for (f = fds; f < &fds[nfds]; ++f)
 230         {
 231           if ((HANDLE) f->fd == handles[ready - WAIT_OBJECT_0])
 232             {
 233               f->revents = f->events;
 234               if (_g_main_poll_debug)
 235                 g_print ("  got event %p\n", (HANDLE) f->fd);
 236             }
 237         }
 238
 239       /* If no timeout and polling several handles, recurse to poll
 240        * the rest of them.
 241        */
 242       if (timeout == 0 && nhandles > 1)
 243         {
 244           /* Remove the handle that fired */
 245           int i;
 246           if (ready < nhandles - 1)
 247             for (i = ready - WAIT_OBJECT_0 + 1; i < nhandles; i++)
 248               handles[i-1] = handles[i];
 249           nhandles--;
 250           recursed_result = poll_rest (FALSE, handles, nhandles, fds, nfds, 0);
 251           return (recursed_result == -1) ? -1 : 1 + recursed_result;
 252         }
 253       return 1;
 254     }
 255
 256   return 0;
 257 }
 258
 259 gint
 260 g_poll (GPollFD *fds,
 261         guint    nfds,
 262         gint     timeout)
 263 {
 264   HANDLE handles[MAXIMUM_WAIT_OBJECTS];
 265   gboolean poll_msgs = FALSE;
 266   GPollFD *f;
 267   gint nhandles = 0;
 268   int retval;
 269
 270   if (_g_main_poll_debug)
 271     g_print ("g_poll: waiting for");
 272
 273   for (f = fds; f < &fds[nfds]; ++f)
 274     if (f->fd == G_WIN32_MSG_HANDLE && (f->events & G_IO_IN))
 275       {
 276         if (_g_main_poll_debug && !poll_msgs)
 277           g_print (" MSG");
 278         poll_msgs = TRUE;
 279       }
 280     else if (f->fd > 0)
 281       {
 282         /* Don't add the same handle several times into the array, as
 283          * docs say that is not allowed, even if it actually does seem
 284          * to work.
 285          */
 286         gint i;
 287
 288         for (i = 0; i < nhandles; i++)
 289           if (handles[i] == (HANDLE) f->fd)
 290             break;
 291
 292         if (i == nhandles)
 293           {
 294             if (nhandles == MAXIMUM_WAIT_OBJECTS)
 295               {
 296                 g_warning ("Too many handles to wait for!\n");
 297                 break;
 298               }
 299             else
 300               {
 301                 if (_g_main_poll_debug)
 302                   g_print (" %p", (HANDLE) f->fd);
 303                 handles[nhandles++] = (HANDLE) f->fd;
 304               }
 305           }
 306       }
 307
 308   if (_g_main_poll_debug)
 309     g_print ("\n");
 310
 311   for (f = fds; f < &fds[nfds]; ++f)
 312     f->revents = 0;
 313
 314   if (timeout == -1)
 315     timeout = INFINITE;
 316
 317   /* Polling for several things? */
 318   if (nhandles > 1 || (nhandles > 0 && poll_msgs))
 319     {
 320       /* First check if one or several of them are immediately
 321        * available
 322        */
 323       retval = poll_rest (poll_msgs, handles, nhandles, fds, nfds, 0);
 324
 325       /* If not, and we have a significant timeout, poll again with
 326        * timeout then. Note that this will return indication for only
 327        * one event, or only for messages. We ignore timeouts less than
 328        * ten milliseconds as they are mostly pointless on Windows, the
 329        * MsgWaitForMultipleObjectsEx() call will timeout right away
 330        * anyway.
 331        */
 332       if (retval == 0 && (timeout == INFINITE || timeout >= 10))
 333         retval = poll_rest (poll_msgs, handles, nhandles, fds, nfds, timeout);
 334     }
 335   else
 336     {
 337       /* Just polling for one thing, so no need to check first if
 338        * available immediately
 339        */
 340       retval = poll_rest (poll_msgs, handles, nhandles, fds, nfds, timeout);
 341     }
 342
 343   if (retval == -1)
 344     for (f = fds; f < &fds[nfds]; ++f)
 345       f->revents = 0;
 346
 347   return retval;
 348 }
 349
 350 #else  /* !G_OS_WIN32 */
 351
 352 /* The following implementation of poll() comes from the GNU C Library.
 353  * Copyright (C) 1994, 1996, 1997 Free Software Foundation, Inc.
 354  */
 355
 356 #include <string.h> /* for bzero on BSD systems */
 357
 358 #ifdef HAVE_SYS_SELECT_H
 359 #include <sys/select.h>
 360 #endif /* HAVE_SYS_SELECT_H */
 361
 362 #ifdef G_OS_BEOS
 363 #undef NO_FD_SET
 364 #endif /* G_OS_BEOS */
 365
 366 #ifndef NO_FD_SET
 367 #  define SELECT_MASK fd_set
 368 #else /* !NO_FD_SET */
 369 #  ifndef _AIX
 370 typedef long fd_mask;
 371 #  endif /* _AIX */
 372 #  ifdef _IBMR2
 373 #    define SELECT_MASK void
 374 #  else /* !_IBMR2 */
 375 #    define SELECT_MASK int
 376 #  endif /* !_IBMR2 */
 377 #endif /* !NO_FD_SET */
 378
 379 gint
 380 g_poll (GPollFD *fds,
 381         guint    nfds,
 382         gint     timeout)
 383 {
 384   struct timeval tv;
 385   SELECT_MASK rset, wset, xset;
 386   GPollFD *f;
 387   int ready;
 388   int maxfd = 0;
 389
 390   FD_ZERO (&rset);
 391   FD_ZERO (&wset);
 392   FD_ZERO (&xset);
 393
 394   for (f = fds; f < &fds[nfds]; ++f)
 395     if (f->fd >= 0)
 396       {
 397         if (f->events & G_IO_IN)
 398           FD_SET (f->fd, &rset);
 399         if (f->events & G_IO_OUT)
 400           FD_SET (f->fd, &wset);
 401         if (f->events & G_IO_PRI)
 402           FD_SET (f->fd, &xset);
 403         if (f->fd > maxfd && (f->events & (G_IO_IN|G_IO_OUT|G_IO_PRI)))
 404           maxfd = f->fd;
 405       }
 406
 407   tv.tv_sec = timeout / 1000;
 408   tv.tv_usec = (timeout % 1000) * 1000;
 409
 410   ready = select (maxfd + 1, &rset, &wset, &xset,
 411                   timeout == -1 ? NULL : &tv);
 412   if (ready > 0)
 413     for (f = fds; f < &fds[nfds]; ++f)
 414       {
 415         f->revents = 0;
 416         if (f->fd >= 0)
 417           {
 418             if (FD_ISSET (f->fd, &rset))
 419               f->revents |= G_IO_IN;
 420             if (FD_ISSET (f->fd, &wset))
 421               f->revents |= G_IO_OUT;
 422             if (FD_ISSET (f->fd, &xset))
 423               f->revents |= G_IO_PRI;
 424           }
 425       }
 426
 427   return ready;
 428 }
 429
 430 #endif /* !G_OS_WIN32 */
 431
 432 #endif  /* !HAVE_POLL */