1 /* Emulation for select(2)
2 Contributed by Paolo Bonzini.
3
4 Copyright 2008-2022 Free Software Foundation, Inc.
5
6 This file is part of gnulib.
7
8 This file is free software: you can redistribute it and/or modify
9 it under the terms of the GNU Lesser General Public License as
10 published by the Free Software Foundation; either version 2.1 of the
11 License, or (at your option) any later version.
12
13 This file 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
16 GNU Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with this program. If not, see <https://www.gnu.org/licenses/>. */
20
21 #include <config.h>
22
23 /* Specification. */
24 #include <sys/select.h>
25
26 #if defined _WIN32 && ! defined __CYGWIN__
27 /* Native Windows. */
28
29 #include <alloca.h>
30 #include <assert.h>
31 #include <sys/types.h>
32 #include <errno.h>
33 #include <limits.h>
34
35 #include <winsock2.h>
36 #include <windows.h>
37 #include <io.h>
38 #include <stdio.h>
39 #include <conio.h>
40 #include <time.h>
41
42 /* Get the overridden 'struct timeval'. */
43 #include <sys/time.h>
44
45 #if GNULIB_MSVC_NOTHROW
46 # include "msvc-nothrow.h"
47 #else
48 # include <io.h>
49 #endif
50
51 #undef select
52
53 /* Don't assume that UNICODE is not defined. */
54 #undef GetModuleHandle
55 #define GetModuleHandle GetModuleHandleA
56 #undef PeekConsoleInput
57 #define PeekConsoleInput PeekConsoleInputA
58 #undef CreateEvent
59 #define CreateEvent CreateEventA
60 #undef PeekMessage
61 #define PeekMessage PeekMessageA
62 #undef DispatchMessage
63 #define DispatchMessage DispatchMessageA
64
65 /* Avoid warnings from gcc -Wcast-function-type. */
66 #define GetProcAddress \
67 (void *) GetProcAddress
68
69 struct bitset {
70 unsigned char in[FD_SETSIZE / CHAR_BIT];
71 unsigned char out[FD_SETSIZE / CHAR_BIT];
72 };
73
74 /* Declare data structures for ntdll functions. */
75 typedef struct _FILE_PIPE_LOCAL_INFORMATION {
76 ULONG NamedPipeType;
77 ULONG NamedPipeConfiguration;
78 ULONG MaximumInstances;
79 ULONG CurrentInstances;
80 ULONG InboundQuota;
81 ULONG ReadDataAvailable;
82 ULONG OutboundQuota;
83 ULONG WriteQuotaAvailable;
84 ULONG NamedPipeState;
85 ULONG NamedPipeEnd;
86 } FILE_PIPE_LOCAL_INFORMATION, *PFILE_PIPE_LOCAL_INFORMATION;
87
88 typedef struct _IO_STATUS_BLOCK
89 {
90 union {
91 DWORD Status;
92 PVOID Pointer;
93 } u;
94 ULONG_PTR Information;
95 } IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
96
97 typedef enum _FILE_INFORMATION_CLASS {
98 FilePipeLocalInformation = 24
99 } FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS;
100
101 typedef DWORD (WINAPI *PNtQueryInformationFile)
102 (HANDLE, IO_STATUS_BLOCK *, VOID *, ULONG, FILE_INFORMATION_CLASS);
103
104 #ifndef PIPE_BUF
105 #define PIPE_BUF 512
106 #endif
107
108 static BOOL IsConsoleHandle (HANDLE h)
109 {
110 DWORD mode;
111 return GetConsoleMode (h, &mode) != 0;
112 }
113
114 static BOOL
115 IsSocketHandle (HANDLE h)
116 {
117 WSANETWORKEVENTS ev;
118
119 if (IsConsoleHandle (h))
120 return FALSE;
121
122 /* Under Wine, it seems that getsockopt returns 0 for pipes too.
123 WSAEnumNetworkEvents instead distinguishes the two correctly. */
124 ev.lNetworkEvents = 0xDEADBEEF;
125 WSAEnumNetworkEvents ((SOCKET) h, NULL, &ev);
126 return ev.lNetworkEvents != 0xDEADBEEF;
127 }
128
129 /* Compute output fd_sets for libc descriptor FD (whose Windows handle is
130 H). */
131
132 static int
133 windows_poll_handle (HANDLE h, int fd,
134 struct bitset *rbits,
135 struct bitset *wbits,
136 struct bitset *xbits)
137 {
138 BOOL read, write, except;
139 int i, ret;
140 INPUT_RECORD *irbuffer;
141 DWORD avail, nbuffer;
142 BOOL bRet;
143 IO_STATUS_BLOCK iosb;
144 FILE_PIPE_LOCAL_INFORMATION fpli;
145 static PNtQueryInformationFile NtQueryInformationFile;
146 static BOOL once_only;
147
148 read = write = except = FALSE;
149 switch (GetFileType (h))
150 {
151 case FILE_TYPE_DISK:
152 read = TRUE;
153 write = TRUE;
154 break;
155
156 case FILE_TYPE_PIPE:
157 if (!once_only)
158 {
159 NtQueryInformationFile = (PNtQueryInformationFile)
160 GetProcAddress (GetModuleHandle ("ntdll.dll"),
161 "NtQueryInformationFile");
162 once_only = TRUE;
163 }
164
165 if (PeekNamedPipe (h, NULL, 0, NULL, &avail, NULL) != 0)
166 {
167 if (avail)
168 read = TRUE;
169 }
170 else if (GetLastError () == ERROR_BROKEN_PIPE)
171 ;
172
173 else
174 {
175 /* It was the write-end of the pipe. Check if it is writable.
176 If NtQueryInformationFile fails, optimistically assume the pipe is
177 writable. This could happen on Windows 9x, where
178 NtQueryInformationFile is not available, or if we inherit a pipe
179 that doesn't permit FILE_READ_ATTRIBUTES access on the write end
180 (I think this should not happen since Windows XP SP2; WINE seems
181 fine too). Otherwise, ensure that enough space is available for
182 atomic writes. */
183 memset (&iosb, 0, sizeof (iosb));
184 memset (&fpli, 0, sizeof (fpli));
185
186 if (!NtQueryInformationFile
187 || NtQueryInformationFile (h, &iosb, &fpli, sizeof (fpli),
188 FilePipeLocalInformation)
189 || fpli.WriteQuotaAvailable >= PIPE_BUF
190 || (fpli.OutboundQuota < PIPE_BUF &&
191 fpli.WriteQuotaAvailable == fpli.OutboundQuota))
192 write = TRUE;
193 }
194 break;
195
196 case FILE_TYPE_CHAR:
197 write = TRUE;
198 if (!(rbits->in[fd / CHAR_BIT] & (1 << (fd & (CHAR_BIT - 1)))))
199 break;
200
201 ret = WaitForSingleObject (h, 0);
202 if (ret == WAIT_OBJECT_0)
203 {
204 if (!IsConsoleHandle (h))
205 {
206 read = TRUE;
207 break;
208 }
209
210 nbuffer = avail = 0;
211 bRet = GetNumberOfConsoleInputEvents (h, &nbuffer);
212
213 /* Screen buffers handles are filtered earlier. */
214 assert (bRet);
215 if (nbuffer == 0)
216 {
217 except = TRUE;
218 break;
219 }
220
221 irbuffer = (INPUT_RECORD *) alloca (nbuffer * sizeof (INPUT_RECORD));
222 bRet = PeekConsoleInput (h, irbuffer, nbuffer, &avail);
223 if (!bRet || avail == 0)
224 {
225 except = TRUE;
226 break;
227 }
228
229 for (i = 0; i < avail; i++)
230 if (irbuffer[i].EventType == KEY_EVENT)
231 read = TRUE;
232 }
233 break;
234
235 default:
236 ret = WaitForSingleObject (h, 0);
237 write = TRUE;
238 if (ret == WAIT_OBJECT_0)
239 read = TRUE;
240
241 break;
242 }
243
244 ret = 0;
245 if (read && (rbits->in[fd / CHAR_BIT] & (1 << (fd & (CHAR_BIT - 1)))))
246 {
247 rbits->out[fd / CHAR_BIT] |= (1 << (fd & (CHAR_BIT - 1)));
248 ret++;
249 }
250
251 if (write && (wbits->in[fd / CHAR_BIT] & (1 << (fd & (CHAR_BIT - 1)))))
252 {
253 wbits->out[fd / CHAR_BIT] |= (1 << (fd & (CHAR_BIT - 1)));
254 ret++;
255 }
256
257 if (except && (xbits->in[fd / CHAR_BIT] & (1 << (fd & (CHAR_BIT - 1)))))
258 {
259 xbits->out[fd / CHAR_BIT] |= (1 << (fd & (CHAR_BIT - 1)));
260 ret++;
261 }
262
263 return ret;
264 }
265
266 int
267 rpl_select (int nfds, fd_set *rfds, fd_set *wfds, fd_set *xfds,
268 struct timeval *timeout)
269 #undef timeval
270 {
271 static struct timeval tv0;
272 static HANDLE hEvent;
273 HANDLE h, handle_array[FD_SETSIZE + 2];
274 fd_set handle_rfds, handle_wfds, handle_xfds;
275 struct bitset rbits, wbits, xbits;
276 unsigned char anyfds_in[FD_SETSIZE / CHAR_BIT];
277 DWORD ret, wait_timeout, nhandles, nsock, nbuffer;
278 MSG msg;
279 int i, fd, rc;
280 clock_t tend;
281
282 if (nfds > FD_SETSIZE)
283 nfds = FD_SETSIZE;
284
285 if (!timeout)
286 wait_timeout = INFINITE;
287 else
288 {
289 wait_timeout = timeout->tv_sec * 1000 + timeout->tv_usec / 1000;
290
291 /* select is also used as a portable usleep. */
292 if (!rfds && !wfds && !xfds)
293 {
294 Sleep (wait_timeout);
295 return 0;
296 }
297 }
298
299 if (!hEvent)
300 hEvent = CreateEvent (NULL, FALSE, FALSE, NULL);
301
302 handle_array[0] = hEvent;
303 nhandles = 1;
304 nsock = 0;
305
306 /* Copy descriptors to bitsets. At the same time, eliminate
307 bits in the "wrong" direction for console input buffers
308 and screen buffers, because screen buffers are waitable
309 and they will block until a character is available. */
310 memset (&rbits, 0, sizeof (rbits));
311 memset (&wbits, 0, sizeof (wbits));
312 memset (&xbits, 0, sizeof (xbits));
313 memset (anyfds_in, 0, sizeof (anyfds_in));
314 if (rfds)
315 for (i = 0; i < rfds->fd_count; i++)
316 {
317 fd = rfds->fd_array[i];
318 h = (HANDLE) _get_osfhandle (fd);
319 if (IsConsoleHandle (h)
320 && !GetNumberOfConsoleInputEvents (h, &nbuffer))
321 continue;
322
323 rbits.in[fd / CHAR_BIT] |= 1 << (fd & (CHAR_BIT - 1));
324 anyfds_in[fd / CHAR_BIT] |= 1 << (fd & (CHAR_BIT - 1));
325 }
326 else
327 rfds = (fd_set *) alloca (sizeof (fd_set));
328
329 if (wfds)
330 for (i = 0; i < wfds->fd_count; i++)
331 {
332 fd = wfds->fd_array[i];
333 h = (HANDLE) _get_osfhandle (fd);
334 if (IsConsoleHandle (h)
335 && GetNumberOfConsoleInputEvents (h, &nbuffer))
336 continue;
337
338 wbits.in[fd / CHAR_BIT] |= 1 << (fd & (CHAR_BIT - 1));
339 anyfds_in[fd / CHAR_BIT] |= 1 << (fd & (CHAR_BIT - 1));
340 }
341 else
342 wfds = (fd_set *) alloca (sizeof (fd_set));
343
344 if (xfds)
345 for (i = 0; i < xfds->fd_count; i++)
346 {
347 fd = xfds->fd_array[i];
348 xbits.in[fd / CHAR_BIT] |= 1 << (fd & (CHAR_BIT - 1));
349 anyfds_in[fd / CHAR_BIT] |= 1 << (fd & (CHAR_BIT - 1));
350 }
351 else
352 xfds = (fd_set *) alloca (sizeof (fd_set));
353
354 /* Zero all the fd_sets, including the application's. */
355 FD_ZERO (rfds);
356 FD_ZERO (wfds);
357 FD_ZERO (xfds);
358 FD_ZERO (&handle_rfds);
359 FD_ZERO (&handle_wfds);
360 FD_ZERO (&handle_xfds);
361
362 /* Classify handles. Create fd sets for sockets, poll the others. */
363 for (i = 0; i < nfds; i++)
364 {
365 if ((anyfds_in[i / CHAR_BIT] & (1 << (i & (CHAR_BIT - 1)))) == 0)
366 continue;
367
368 h = (HANDLE) _get_osfhandle (i);
369 if (!h)
370 {
371 errno = EBADF;
372 return -1;
373 }
374
375 if (IsSocketHandle (h))
376 {
377 int requested = FD_CLOSE;
378
379 /* See above; socket handles are mapped onto select, but we
380 need to map descriptors to handles. */
381 if (rbits.in[i / CHAR_BIT] & (1 << (i & (CHAR_BIT - 1))))
382 {
383 requested |= FD_READ | FD_ACCEPT;
384 FD_SET ((SOCKET) h, rfds);
385 FD_SET ((SOCKET) h, &handle_rfds);
386 }
387 if (wbits.in[i / CHAR_BIT] & (1 << (i & (CHAR_BIT - 1))))
388 {
389 requested |= FD_WRITE | FD_CONNECT;
390 FD_SET ((SOCKET) h, wfds);
391 FD_SET ((SOCKET) h, &handle_wfds);
392 }
393 if (xbits.in[i / CHAR_BIT] & (1 << (i & (CHAR_BIT - 1))))
394 {
395 requested |= FD_OOB;
396 FD_SET ((SOCKET) h, xfds);
397 FD_SET ((SOCKET) h, &handle_xfds);
398 }
399
400 WSAEventSelect ((SOCKET) h, hEvent, requested);
401 nsock++;
402 }
403 else
404 {
405 handle_array[nhandles++] = h;
406
407 /* Poll now. If we get an event, do not wait below. */
408 if (wait_timeout != 0
409 && windows_poll_handle (h, i, &rbits, &wbits, &xbits))
410 wait_timeout = 0;
411 }
412 }
413
414 /* Place a sentinel at the end of the array. */
415 handle_array[nhandles] = NULL;
416
417 /* When will the waiting period expire? */
418 if (wait_timeout != INFINITE)
419 tend = clock () + wait_timeout;
420
421 restart:
422 if (wait_timeout == 0 || nsock == 0)
423 rc = 0;
424 else
425 {
426 /* See if we need to wait in the loop below. If any select is ready,
427 do MsgWaitForMultipleObjects anyway to dispatch messages, but
428 no need to call select again. */
429 rc = select (0, &handle_rfds, &handle_wfds, &handle_xfds, &tv0);
430 if (rc == 0)
431 {
432 /* Restore the fd_sets for the other select we do below. */
433 memcpy (&handle_rfds, rfds, sizeof (fd_set));
434 memcpy (&handle_wfds, wfds, sizeof (fd_set));
435 memcpy (&handle_xfds, xfds, sizeof (fd_set));
436 }
437 else
438 wait_timeout = 0;
439 }
440
441 /* How much is left to wait? */
442 if (wait_timeout != INFINITE)
443 {
444 clock_t tnow = clock ();
445 if (tend >= tnow)
446 wait_timeout = tend - tnow;
447 else
448 wait_timeout = 0;
449 }
450
451 for (;;)
452 {
453 ret = MsgWaitForMultipleObjects (nhandles, handle_array, FALSE,
454 wait_timeout, QS_ALLINPUT);
455
456 if (ret == WAIT_OBJECT_0 + nhandles)
457 {
458 /* new input of some other kind */
459 BOOL bRet;
460 while ((bRet = PeekMessage (&msg, NULL, 0, 0, PM_REMOVE)) != 0)
461 {
462 TranslateMessage (&msg);
463 DispatchMessage (&msg);
464 }
465 }
466 else
467 break;
468 }
469
470 /* If we haven't done it yet, check the status of the sockets. */
471 if (rc == 0 && nsock > 0)
472 rc = select (0, &handle_rfds, &handle_wfds, &handle_xfds, &tv0);
473
474 if (nhandles > 1)
475 {
476 /* Count results that are not counted in the return value of select. */
477 nhandles = 1;
478 for (i = 0; i < nfds; i++)
479 {
480 if ((anyfds_in[i / CHAR_BIT] & (1 << (i & (CHAR_BIT - 1)))) == 0)
481 continue;
482
483 h = (HANDLE) _get_osfhandle (i);
484 if (h == handle_array[nhandles])
485 {
486 /* Not a socket. */
487 nhandles++;
488 windows_poll_handle (h, i, &rbits, &wbits, &xbits);
489 if (rbits.out[i / CHAR_BIT] & (1 << (i & (CHAR_BIT - 1)))
490 || wbits.out[i / CHAR_BIT] & (1 << (i & (CHAR_BIT - 1)))
491 || xbits.out[i / CHAR_BIT] & (1 << (i & (CHAR_BIT - 1))))
492 rc++;
493 }
494 }
495
496 if (rc == 0
497 && (wait_timeout == INFINITE
498 /* If NHANDLES > 1, but no bits are set, it means we've
499 been told incorrectly that some handle was signaled.
500 This happens with anonymous pipes, which always cause
501 MsgWaitForMultipleObjects to exit immediately, but no
502 data is found ready to be read by windows_poll_handle.
503 To avoid a total failure (whereby we return zero and
504 don't wait at all), let's poll in a more busy loop. */
505 || (wait_timeout != 0 && nhandles > 1)))
506 {
507 /* Sleep 1 millisecond to avoid busy wait and retry with the
508 original fd_sets. */
509 memcpy (&handle_rfds, rfds, sizeof (fd_set));
510 memcpy (&handle_wfds, wfds, sizeof (fd_set));
511 memcpy (&handle_xfds, xfds, sizeof (fd_set));
512 SleepEx (1, TRUE);
513 goto restart;
514 }
515 if (timeout && wait_timeout == 0 && rc == 0)
516 timeout->tv_sec = timeout->tv_usec = 0;
517 }
518
519 /* Now fill in the results. */
520 FD_ZERO (rfds);
521 FD_ZERO (wfds);
522 FD_ZERO (xfds);
523 nhandles = 1;
524 for (i = 0; i < nfds; i++)
525 {
526 if ((anyfds_in[i / CHAR_BIT] & (1 << (i & (CHAR_BIT - 1)))) == 0)
527 continue;
528
529 h = (HANDLE) _get_osfhandle (i);
530 if (h != handle_array[nhandles])
531 {
532 /* Perform handle->descriptor mapping. */
533 SOCKET s = (SOCKET) h;
534 WSAEventSelect (s, NULL, 0);
535 if (FD_ISSET (s, &handle_rfds))
536 FD_SET (i, rfds);
537 if (FD_ISSET (s, &handle_wfds))
538 FD_SET (i, wfds);
539 if (FD_ISSET (s, &handle_xfds))
540 FD_SET (i, xfds);
541 }
542 else
543 {
544 /* Not a socket. */
545 nhandles++;
546 if (rbits.out[i / CHAR_BIT] & (1 << (i & (CHAR_BIT - 1))))
547 FD_SET (i, rfds);
548 if (wbits.out[i / CHAR_BIT] & (1 << (i & (CHAR_BIT - 1))))
549 FD_SET (i, wfds);
550 if (xbits.out[i / CHAR_BIT] & (1 << (i & (CHAR_BIT - 1))))
551 FD_SET (i, xfds);
552 }
553 }
554
555 return rc;
556 }
557
558 #else /* ! Native Windows. */
559
560 #include <stddef.h> /* NULL */
561 #include <errno.h>
562 #include <unistd.h>
563
564 #undef select
565
566 int
567 rpl_select (int nfds, fd_set *rfds, fd_set *wfds, fd_set *xfds,
568 struct timeval *timeout)
569 {
570 int i;
571
572 /* FreeBSD 8.2 has a bug: it does not always detect invalid fds. */
573 if (nfds < 0 || nfds > FD_SETSIZE)
574 {
575 errno = EINVAL;
576 return -1;
577 }
578 for (i = 0; i < nfds; i++)
579 {
580 if (((rfds && FD_ISSET (i, rfds))
581 || (wfds && FD_ISSET (i, wfds))
582 || (xfds && FD_ISSET (i, xfds)))
583 && dup2 (i, i) != i)
584 return -1;
585 }
586
587 /* Interix 3.5 has a bug: it does not support nfds == 0. */
588 if (nfds == 0)
589 {
590 nfds = 1;
591 rfds = NULL;
592 wfds = NULL;
593 xfds = NULL;
594 }
595 return select (nfds, rfds, wfds, xfds, timeout);
596 }
597
598 #endif