1 /* GLIB - Library of useful routines for C programming
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
4 * gpoll.c: poll(2) abstraction
5 * Copyright 1998 Owen Taylor
6 * Copyright 2008 Red Hat, Inc.
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.1 of the License, or (at your option) any later version.
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.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
23 * Modified by the GLib Team and others 1997-2000. See the AUTHORS
24 * file for a list of people on the GLib Team. See the ChangeLog
25 * files for a list of changes. These files are distributed with
26 * GLib at ftp://ftp.gtk.org/pub/gtk/.
34 #include "glibconfig.h"
35 #include "giochannel.h"
37 /* Uncomment the next line (and the corresponding line in gmain.c) to
38 * enable debugging printouts if the environment variable
39 * G_MAIN_POLL_DEBUG is set to some value.
41 /* #define G_MAIN_POLL_DEBUG */
44 /* Always enable debugging printout on Windows, as it is more often
47 #define G_MAIN_POLL_DEBUG
50 #include <sys/types.h>
53 #ifdef HAVE_SYS_TIME_H
55 #endif /* HAVE_SYS_TIME_H */
59 /* The poll() emulation on OS/X doesn't handle fds=NULL, nfds=0,
60 * so we prefer our own poll emulation.
62 #if defined(_POLL_EMUL_H_) || defined(BROKEN_POLL)
66 #endif /* GLIB_HAVE_SYS_POLL_H */
69 #endif /* G_OS_UNIX */
75 #endif /* G_OS_WIN32 */
83 #ifdef G_MAIN_POLL_DEBUG
84 extern gboolean _g_main_poll_debug;
91 * @fds: file descriptors to poll
92 * @nfds: the number of file descriptors in @fds
93 * @timeout: amount of time to wait, in milliseconds, or -1 to wait forever
95 * Polls @fds, as with the poll() system call, but portably. (On
96 * systems that don't have poll(), it is emulated using select().)
97 * This is used internally by #GMainContext, but it can be called
98 * directly if you need to block until a file descriptor is ready, but
99 * don't want to run the full main loop.
101 * Each element of @fds is a #GPollFD describing a single file
102 * descriptor to poll. The %fd field indicates the file descriptor,
103 * and the %events field indicates the events to poll for. On return,
104 * the %revents fields will be filled with the events that actually
107 * On POSIX systems, the file descriptors in @fds can be any sort of
108 * file descriptor, but the situation is much more complicated on
109 * Windows. If you need to use g_poll() in code that has to run on
110 * Windows, the easiest solution is to construct all of your
111 * #GPollFDs with g_io_channel_win32_make_pollfd().
113 * Returns: the number of entries in @fds whose %revents fields
114 * were filled in, or 0 if the operation timed out, or -1 on error or
115 * if the call was interrupted.
120 g_poll (GPollFD *fds,
124 return poll ((struct pollfd *)fds, nfds, timeout);
127 #else /* !HAVE_POLL */
132 poll_rest (GPollFD *msg_fd,
134 GPollFD *handle_to_fd[],
144 /* Wait for either messages or handles
145 * -> Use MsgWaitForMultipleObjectsEx
147 if (_g_main_poll_debug)
148 g_print (" MsgWaitForMultipleObjectsEx(%d, %d)\n", nhandles, timeout);
150 ready = MsgWaitForMultipleObjectsEx (nhandles, handles, timeout,
151 QS_ALLINPUT, MWMO_ALERTABLE);
153 if (ready == WAIT_FAILED)
155 gchar *emsg = g_win32_error_message (GetLastError ());
156 g_warning ("MsgWaitForMultipleObjectsEx failed: %s", emsg);
160 else if (nhandles == 0)
162 /* No handles to wait for, just the timeout */
163 if (timeout == INFINITE)
167 /* Wait for the current process to die, more efficient than SleepEx(). */
168 WaitForSingleObjectEx (GetCurrentProcess (), timeout, TRUE);
169 ready = WAIT_TIMEOUT;
174 /* Wait for just handles
175 * -> Use WaitForMultipleObjectsEx
177 if (_g_main_poll_debug)
178 g_print (" WaitForMultipleObjectsEx(%d, %d)\n", nhandles, timeout);
180 ready = WaitForMultipleObjectsEx (nhandles, handles, FALSE, timeout, TRUE);
181 if (ready == WAIT_FAILED)
183 gchar *emsg = g_win32_error_message (GetLastError ());
184 g_warning ("WaitForMultipleObjectsEx failed: %s", emsg);
189 if (_g_main_poll_debug)
190 g_print (" wait returns %ld%s\n",
192 (ready == WAIT_FAILED ? " (WAIT_FAILED)" :
193 (ready == WAIT_TIMEOUT ? " (WAIT_TIMEOUT)" :
194 (msg_fd != NULL && ready == WAIT_OBJECT_0 + nhandles ? " (msg)" : ""))));
196 if (ready == WAIT_FAILED)
198 else if (ready == WAIT_TIMEOUT ||
199 ready == WAIT_IO_COMPLETION)
201 else if (msg_fd != NULL && ready == WAIT_OBJECT_0 + nhandles)
203 msg_fd->revents |= G_IO_IN;
205 /* If we have a timeout, or no handles to poll, be satisfied
206 * with just noticing we have messages waiting.
208 if (timeout != 0 || nhandles == 0)
211 /* If no timeout and handles to poll, recurse to poll them,
214 recursed_result = poll_rest (NULL, handles, handle_to_fd, nhandles, 0);
215 return (recursed_result == -1) ? -1 : 1 + recursed_result;
217 else if (ready >= WAIT_OBJECT_0 && ready < WAIT_OBJECT_0 + nhandles)
219 f = handle_to_fd[ready - WAIT_OBJECT_0];
220 f->revents = f->events;
221 if (_g_main_poll_debug)
222 g_print (" got event %p\n", (HANDLE) f->fd);
224 /* If no timeout and polling several handles, recurse to poll
227 if (timeout == 0 && nhandles > 1)
229 /* Poll the handles with index > ready */
230 HANDLE *shorter_handles;
231 GPollFD **shorter_handle_to_fd;
232 gint shorter_nhandles;
234 shorter_handles = &handles[ready - WAIT_OBJECT_0 + 1];
235 shorter_handle_to_fd = &handle_to_fd[ready - WAIT_OBJECT_0 + 1];
236 shorter_nhandles = nhandles - (ready - WAIT_OBJECT_0 + 1);
238 recursed_result = poll_rest (NULL, shorter_handles, shorter_handle_to_fd, shorter_nhandles, 0);
239 return (recursed_result == -1) ? -1 : 1 + recursed_result;
248 g_poll (GPollFD *fds,
252 HANDLE handles[MAXIMUM_WAIT_OBJECTS];
253 GPollFD *handle_to_fd[MAXIMUM_WAIT_OBJECTS];
254 GPollFD *msg_fd = NULL;
259 if (_g_main_poll_debug)
260 g_print ("g_poll: waiting for");
262 for (f = fds; f < &fds[nfds]; ++f)
264 if (f->fd == G_WIN32_MSG_HANDLE && (f->events & G_IO_IN))
266 if (_g_main_poll_debug && msg_fd == NULL)
272 if (nhandles == MAXIMUM_WAIT_OBJECTS)
274 g_warning ("Too many handles to wait for!\n");
279 if (_g_main_poll_debug)
280 g_print (" %p", (HANDLE) f->fd);
281 handle_to_fd[nhandles] = f;
282 handles[nhandles++] = (HANDLE) f->fd;
288 if (_g_main_poll_debug)
294 /* Polling for several things? */
295 if (nhandles > 1 || (nhandles > 0 && msg_fd != NULL))
297 /* First check if one or several of them are immediately
300 retval = poll_rest (msg_fd, handles, handle_to_fd, nhandles, 0);
302 /* If not, and we have a significant timeout, poll again with
303 * timeout then. Note that this will return indication for only
304 * one event, or only for messages.
306 if (retval == 0 && (timeout == INFINITE || timeout > 0))
307 retval = poll_rest (msg_fd, handles, handle_to_fd, nhandles, timeout);
311 /* Just polling for one thing, so no need to check first if
312 * available immediately
314 retval = poll_rest (msg_fd, handles, handle_to_fd, nhandles, timeout);
318 for (f = fds; f < &fds[nfds]; ++f)
324 #else /* !G_OS_WIN32 */
326 /* The following implementation of poll() comes from the GNU C Library.
327 * Copyright (C) 1994, 1996, 1997 Free Software Foundation, Inc.
330 #include <string.h> /* for bzero on BSD systems */
332 #ifdef HAVE_SYS_SELECT_H
333 #include <sys/select.h>
334 #endif /* HAVE_SYS_SELECT_H */
337 # define SELECT_MASK fd_set
338 #else /* !NO_FD_SET */
340 typedef long fd_mask;
343 # define SELECT_MASK void
345 # define SELECT_MASK int
346 # endif /* !_IBMR2 */
347 #endif /* !NO_FD_SET */
350 g_poll (GPollFD *fds,
355 SELECT_MASK rset, wset, xset;
364 for (f = fds; f < &fds[nfds]; ++f)
367 if (f->events & G_IO_IN)
368 FD_SET (f->fd, &rset);
369 if (f->events & G_IO_OUT)
370 FD_SET (f->fd, &wset);
371 if (f->events & G_IO_PRI)
372 FD_SET (f->fd, &xset);
373 if (f->fd > maxfd && (f->events & (G_IO_IN|G_IO_OUT|G_IO_PRI)))
377 tv.tv_sec = timeout / 1000;
378 tv.tv_usec = (timeout % 1000) * 1000;
380 ready = select (maxfd + 1, &rset, &wset, &xset,
381 timeout == -1 ? NULL : &tv);
383 for (f = fds; f < &fds[nfds]; ++f)
388 if (FD_ISSET (f->fd, &rset))
389 f->revents |= G_IO_IN;
390 if (FD_ISSET (f->fd, &wset))
391 f->revents |= G_IO_OUT;
392 if (FD_ISSET (f->fd, &xset))
393 f->revents |= G_IO_PRI;
400 #endif /* !G_OS_WIN32 */
402 #endif /* !HAVE_POLL */