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