Merge branch 'jk/perf-no-dups'
[git/git.git] / compat / poll / poll.c
1 /* Emulation for poll(2)
2 Contributed by Paolo Bonzini.
3
4 Copyright 2001-2003, 2006-2011 Free Software Foundation, Inc.
5
6 This file is part of gnulib.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 This program 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 General Public License for more details.
17
18 You should have received a copy of the GNU General Public License along
19 with this program; if not, see <http://www.gnu.org/licenses/>. */
20
21 /* To bump the minimum Windows version to Windows Vista */
22 #include "git-compat-util.h"
23
24 /* Tell gcc not to warn about the (nfd < 0) tests, below. */
25 #if (__GNUC__ == 4 && 3 <= __GNUC_MINOR__) || 4 < __GNUC__
26 # pragma GCC diagnostic ignored "-Wtype-limits"
27 #endif
28
29 #if defined(WIN32)
30 # include <malloc.h>
31 #endif
32
33 #include <sys/types.h>
34
35 #include <errno.h>
36 #include <limits.h>
37 #include <assert.h>
38
39 #if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
40 # define WIN32_NATIVE
41 # if defined (_MSC_VER) && !defined(_WIN32_WINNT)
42 # define _WIN32_WINNT 0x0502
43 # endif
44 # include <winsock2.h>
45 # include <windows.h>
46 # include <io.h>
47 # include <stdio.h>
48 # include <conio.h>
49 #else
50 # include <sys/time.h>
51 # include <sys/socket.h>
52 # ifndef NO_SYS_SELECT_H
53 # include <sys/select.h>
54 # endif
55 # include <unistd.h>
56 #endif
57
58 /* Specification. */
59 #include "poll.h"
60
61 #ifdef HAVE_SYS_IOCTL_H
62 # include <sys/ioctl.h>
63 #endif
64 #ifdef HAVE_SYS_FILIO_H
65 # include <sys/filio.h>
66 #endif
67
68 #include <time.h>
69
70 #ifndef INFTIM
71 # define INFTIM (-1)
72 #endif
73
74 /* BeOS does not have MSG_PEEK. */
75 #ifndef MSG_PEEK
76 # define MSG_PEEK 0
77 #endif
78
79 #ifdef WIN32_NATIVE
80
81 #define IsConsoleHandle(h) (((long) (intptr_t) (h) & 3) == 3)
82
83 static BOOL
84 IsSocketHandle (HANDLE h)
85 {
86 WSANETWORKEVENTS ev;
87
88 if (IsConsoleHandle (h))
89 return FALSE;
90
91 /* Under Wine, it seems that getsockopt returns 0 for pipes too.
92 WSAEnumNetworkEvents instead distinguishes the two correctly. */
93 ev.lNetworkEvents = 0xDEADBEEF;
94 WSAEnumNetworkEvents ((SOCKET) h, NULL, &ev);
95 return ev.lNetworkEvents != 0xDEADBEEF;
96 }
97
98 /* Declare data structures for ntdll functions. */
99 typedef struct _FILE_PIPE_LOCAL_INFORMATION {
100 ULONG NamedPipeType;
101 ULONG NamedPipeConfiguration;
102 ULONG MaximumInstances;
103 ULONG CurrentInstances;
104 ULONG InboundQuota;
105 ULONG ReadDataAvailable;
106 ULONG OutboundQuota;
107 ULONG WriteQuotaAvailable;
108 ULONG NamedPipeState;
109 ULONG NamedPipeEnd;
110 } FILE_PIPE_LOCAL_INFORMATION, *PFILE_PIPE_LOCAL_INFORMATION;
111
112 typedef struct _IO_STATUS_BLOCK
113 {
114 union {
115 DWORD Status;
116 PVOID Pointer;
117 } u;
118 ULONG_PTR Information;
119 } IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
120
121 typedef enum _FILE_INFORMATION_CLASS {
122 FilePipeLocalInformation = 24
123 } FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS;
124
125 typedef DWORD (WINAPI *PNtQueryInformationFile)
126 (HANDLE, IO_STATUS_BLOCK *, VOID *, ULONG, FILE_INFORMATION_CLASS);
127
128 # ifndef PIPE_BUF
129 # define PIPE_BUF 512
130 # endif
131
132 /* Compute revents values for file handle H. If some events cannot happen
133 for the handle, eliminate them from *P_SOUGHT. */
134
135 static int
136 win32_compute_revents (HANDLE h, int *p_sought)
137 {
138 int i, ret, happened;
139 INPUT_RECORD *irbuffer;
140 DWORD avail, nbuffer;
141 BOOL bRet;
142 IO_STATUS_BLOCK iosb;
143 FILE_PIPE_LOCAL_INFORMATION fpli;
144 static PNtQueryInformationFile NtQueryInformationFile;
145 static BOOL once_only;
146
147 switch (GetFileType (h))
148 {
149 case FILE_TYPE_PIPE:
150 if (!once_only)
151 {
152 NtQueryInformationFile = (PNtQueryInformationFile)(void (*)(void))
153 GetProcAddress (GetModuleHandleW (L"ntdll.dll"),
154 "NtQueryInformationFile");
155 once_only = TRUE;
156 }
157
158 happened = 0;
159 if (PeekNamedPipe (h, NULL, 0, NULL, &avail, NULL) != 0)
160 {
161 if (avail)
162 happened |= *p_sought & (POLLIN | POLLRDNORM);
163 }
164 else if (GetLastError () == ERROR_BROKEN_PIPE)
165 happened |= POLLHUP;
166
167 else
168 {
169 /* It was the write-end of the pipe. Check if it is writable.
170 If NtQueryInformationFile fails, optimistically assume the pipe is
171 writable. This could happen on Win9x, where NtQueryInformationFile
172 is not available, or if we inherit a pipe that doesn't permit
173 FILE_READ_ATTRIBUTES access on the write end (I think this should
174 not happen since WinXP SP2; WINE seems fine too). Otherwise,
175 ensure that enough space is available for atomic writes. */
176 memset (&iosb, 0, sizeof (iosb));
177 memset (&fpli, 0, sizeof (fpli));
178
179 if (!NtQueryInformationFile
180 || NtQueryInformationFile (h, &iosb, &fpli, sizeof (fpli),
181 FilePipeLocalInformation)
182 || fpli.WriteQuotaAvailable >= PIPE_BUF
183 || (fpli.OutboundQuota < PIPE_BUF &&
184 fpli.WriteQuotaAvailable == fpli.OutboundQuota))
185 happened |= *p_sought & (POLLOUT | POLLWRNORM | POLLWRBAND);
186 }
187 return happened;
188
189 case FILE_TYPE_CHAR:
190 ret = WaitForSingleObject (h, 0);
191 if (!IsConsoleHandle (h))
192 return ret == WAIT_OBJECT_0 ? *p_sought & ~(POLLPRI | POLLRDBAND) : 0;
193
194 nbuffer = avail = 0;
195 bRet = GetNumberOfConsoleInputEvents (h, &nbuffer);
196 if (bRet)
197 {
198 /* Input buffer. */
199 *p_sought &= POLLIN | POLLRDNORM;
200 if (nbuffer == 0)
201 return POLLHUP;
202 if (!*p_sought)
203 return 0;
204
205 irbuffer = (INPUT_RECORD *) alloca (nbuffer * sizeof (INPUT_RECORD));
206 bRet = PeekConsoleInput (h, irbuffer, nbuffer, &avail);
207 if (!bRet || avail == 0)
208 return POLLHUP;
209
210 for (i = 0; i < avail; i++)
211 if (irbuffer[i].EventType == KEY_EVENT)
212 return *p_sought;
213 return 0;
214 }
215 else
216 {
217 /* Screen buffer. */
218 *p_sought &= POLLOUT | POLLWRNORM | POLLWRBAND;
219 return *p_sought;
220 }
221
222 default:
223 ret = WaitForSingleObject (h, 0);
224 if (ret == WAIT_OBJECT_0)
225 return *p_sought & ~(POLLPRI | POLLRDBAND);
226
227 return *p_sought & (POLLOUT | POLLWRNORM | POLLWRBAND);
228 }
229 }
230
231 /* Convert fd_sets returned by select into revents values. */
232
233 static int
234 win32_compute_revents_socket (SOCKET h, int sought, long lNetworkEvents)
235 {
236 int happened = 0;
237
238 if ((lNetworkEvents & (FD_READ | FD_ACCEPT | FD_CLOSE)) == FD_ACCEPT)
239 happened |= (POLLIN | POLLRDNORM) & sought;
240
241 else if (lNetworkEvents & (FD_READ | FD_ACCEPT | FD_CLOSE))
242 {
243 int r, error;
244
245 char data[64];
246 WSASetLastError (0);
247 r = recv (h, data, sizeof (data), MSG_PEEK);
248 error = WSAGetLastError ();
249 WSASetLastError (0);
250
251 if (r > 0 || error == WSAENOTCONN)
252 happened |= (POLLIN | POLLRDNORM) & sought;
253
254 /* Distinguish hung-up sockets from other errors. */
255 else if (r == 0 || error == WSAESHUTDOWN || error == WSAECONNRESET
256 || error == WSAECONNABORTED || error == WSAENETRESET)
257 happened |= POLLHUP;
258
259 else
260 happened |= POLLERR;
261 }
262
263 if (lNetworkEvents & (FD_WRITE | FD_CONNECT))
264 happened |= (POLLOUT | POLLWRNORM | POLLWRBAND) & sought;
265
266 if (lNetworkEvents & FD_OOB)
267 happened |= (POLLPRI | POLLRDBAND) & sought;
268
269 return happened;
270 }
271
272 #else /* !MinGW */
273
274 /* Convert select(2) returned fd_sets into poll(2) revents values. */
275 static int
276 compute_revents (int fd, int sought, fd_set *rfds, fd_set *wfds, fd_set *efds)
277 {
278 int happened = 0;
279 if (FD_ISSET (fd, rfds))
280 {
281 int r;
282 int socket_errno;
283
284 # if defined __MACH__ && defined __APPLE__
285 /* There is a bug in Mac OS X that causes it to ignore MSG_PEEK
286 for some kinds of descriptors. Detect if this descriptor is a
287 connected socket, a server socket, or something else using a
288 0-byte recv, and use ioctl(2) to detect POLLHUP. */
289 r = recv (fd, NULL, 0, MSG_PEEK);
290 socket_errno = (r < 0) ? errno : 0;
291 if (r == 0 || socket_errno == ENOTSOCK)
292 ioctl (fd, FIONREAD, &r);
293 # else
294 char data[64];
295 r = recv (fd, data, sizeof (data), MSG_PEEK);
296 socket_errno = (r < 0) ? errno : 0;
297 # endif
298 if (r == 0)
299 happened |= POLLHUP;
300
301 /* If the event happened on an unconnected server socket,
302 that's fine. */
303 else if (r > 0 || ( /* (r == -1) && */ socket_errno == ENOTCONN))
304 happened |= (POLLIN | POLLRDNORM) & sought;
305
306 /* Distinguish hung-up sockets from other errors. */
307 else if (socket_errno == ESHUTDOWN || socket_errno == ECONNRESET
308 || socket_errno == ECONNABORTED || socket_errno == ENETRESET)
309 happened |= POLLHUP;
310
311 /* some systems can't use recv() on non-socket, including HP NonStop */
312 else if (/* (r == -1) && */ socket_errno == ENOTSOCK)
313 happened |= (POLLIN | POLLRDNORM) & sought;
314
315 else
316 happened |= POLLERR;
317 }
318
319 if (FD_ISSET (fd, wfds))
320 happened |= (POLLOUT | POLLWRNORM | POLLWRBAND) & sought;
321
322 if (FD_ISSET (fd, efds))
323 happened |= (POLLPRI | POLLRDBAND) & sought;
324
325 return happened;
326 }
327 #endif /* !MinGW */
328
329 int
330 poll (struct pollfd *pfd, nfds_t nfd, int timeout)
331 {
332 #ifndef WIN32_NATIVE
333 fd_set rfds, wfds, efds;
334 struct timeval tv;
335 struct timeval *ptv;
336 int maxfd, rc;
337 nfds_t i;
338
339 # ifdef _SC_OPEN_MAX
340 static int sc_open_max = -1;
341
342 if (nfd < 0
343 || (nfd > sc_open_max
344 && (sc_open_max != -1
345 || nfd > (sc_open_max = sysconf (_SC_OPEN_MAX)))))
346 {
347 errno = EINVAL;
348 return -1;
349 }
350 # else /* !_SC_OPEN_MAX */
351 # ifdef OPEN_MAX
352 if (nfd < 0 || nfd > OPEN_MAX)
353 {
354 errno = EINVAL;
355 return -1;
356 }
357 # endif /* OPEN_MAX -- else, no check is needed */
358 # endif /* !_SC_OPEN_MAX */
359
360 /* EFAULT is not necessary to implement, but let's do it in the
361 simplest case. */
362 if (!pfd && nfd)
363 {
364 errno = EFAULT;
365 return -1;
366 }
367
368 /* convert timeout number into a timeval structure */
369 if (timeout == 0)
370 {
371 ptv = &tv;
372 ptv->tv_sec = 0;
373 ptv->tv_usec = 0;
374 }
375 else if (timeout > 0)
376 {
377 ptv = &tv;
378 ptv->tv_sec = timeout / 1000;
379 ptv->tv_usec = (timeout % 1000) * 1000;
380 }
381 else if (timeout == INFTIM)
382 /* wait forever */
383 ptv = NULL;
384 else
385 {
386 errno = EINVAL;
387 return -1;
388 }
389
390 /* create fd sets and determine max fd */
391 maxfd = -1;
392 FD_ZERO (&rfds);
393 FD_ZERO (&wfds);
394 FD_ZERO (&efds);
395 for (i = 0; i < nfd; i++)
396 {
397 if (pfd[i].fd < 0)
398 continue;
399
400 if (pfd[i].events & (POLLIN | POLLRDNORM))
401 FD_SET (pfd[i].fd, &rfds);
402
403 /* see select(2): "the only exceptional condition detectable
404 is out-of-band data received on a socket", hence we push
405 POLLWRBAND events onto wfds instead of efds. */
406 if (pfd[i].events & (POLLOUT | POLLWRNORM | POLLWRBAND))
407 FD_SET (pfd[i].fd, &wfds);
408 if (pfd[i].events & (POLLPRI | POLLRDBAND))
409 FD_SET (pfd[i].fd, &efds);
410 if (pfd[i].fd >= maxfd
411 && (pfd[i].events & (POLLIN | POLLOUT | POLLPRI
412 | POLLRDNORM | POLLRDBAND
413 | POLLWRNORM | POLLWRBAND)))
414 {
415 maxfd = pfd[i].fd;
416 if (maxfd > FD_SETSIZE)
417 {
418 errno = EOVERFLOW;
419 return -1;
420 }
421 }
422 }
423
424 /* examine fd sets */
425 rc = select (maxfd + 1, &rfds, &wfds, &efds, ptv);
426 if (rc < 0)
427 return rc;
428
429 /* establish results */
430 rc = 0;
431 for (i = 0; i < nfd; i++)
432 if (pfd[i].fd < 0)
433 pfd[i].revents = 0;
434 else
435 {
436 int happened = compute_revents (pfd[i].fd, pfd[i].events,
437 &rfds, &wfds, &efds);
438 if (happened)
439 {
440 pfd[i].revents = happened;
441 rc++;
442 }
443 else
444 {
445 pfd[i].revents = 0;
446 }
447 }
448
449 return rc;
450 #else
451 static struct timeval tv0;
452 static HANDLE hEvent;
453 WSANETWORKEVENTS ev;
454 HANDLE h, handle_array[FD_SETSIZE + 2];
455 DWORD ret, wait_timeout, nhandles, orig_timeout = 0;
456 ULONGLONG start = 0;
457 fd_set rfds, wfds, xfds;
458 BOOL poll_again;
459 MSG msg;
460 int rc = 0;
461 nfds_t i;
462
463 if (nfd < 0 || timeout < -1)
464 {
465 errno = EINVAL;
466 return -1;
467 }
468
469 if (timeout != INFTIM)
470 {
471 orig_timeout = timeout;
472 start = GetTickCount64();
473 }
474
475 if (!hEvent)
476 hEvent = CreateEvent (NULL, FALSE, FALSE, NULL);
477
478 restart:
479 handle_array[0] = hEvent;
480 nhandles = 1;
481 FD_ZERO (&rfds);
482 FD_ZERO (&wfds);
483 FD_ZERO (&xfds);
484
485 /* Classify socket handles and create fd sets. */
486 for (i = 0; i < nfd; i++)
487 {
488 int sought = pfd[i].events;
489 pfd[i].revents = 0;
490 if (pfd[i].fd < 0)
491 continue;
492 if (!(sought & (POLLIN | POLLRDNORM | POLLOUT | POLLWRNORM | POLLWRBAND
493 | POLLPRI | POLLRDBAND)))
494 continue;
495
496 h = (HANDLE) _get_osfhandle (pfd[i].fd);
497 assert (h != NULL);
498 if (IsSocketHandle (h))
499 {
500 int requested = FD_CLOSE;
501
502 /* see above; socket handles are mapped onto select. */
503 if (sought & (POLLIN | POLLRDNORM))
504 {
505 requested |= FD_READ | FD_ACCEPT;
506 FD_SET ((SOCKET) h, &rfds);
507 }
508 if (sought & (POLLOUT | POLLWRNORM | POLLWRBAND))
509 {
510 requested |= FD_WRITE | FD_CONNECT;
511 FD_SET ((SOCKET) h, &wfds);
512 }
513 if (sought & (POLLPRI | POLLRDBAND))
514 {
515 requested |= FD_OOB;
516 FD_SET ((SOCKET) h, &xfds);
517 }
518
519 if (requested)
520 WSAEventSelect ((SOCKET) h, hEvent, requested);
521 }
522 else
523 {
524 /* Poll now. If we get an event, do not poll again. Also,
525 screen buffer handles are waitable, and they'll block until
526 a character is available. win32_compute_revents eliminates
527 bits for the "wrong" direction. */
528 pfd[i].revents = win32_compute_revents (h, &sought);
529 if (sought)
530 handle_array[nhandles++] = h;
531 if (pfd[i].revents)
532 timeout = 0;
533 }
534 }
535
536 if (select (0, &rfds, &wfds, &xfds, &tv0) > 0)
537 {
538 /* Do MsgWaitForMultipleObjects anyway to dispatch messages, but
539 no need to call select again. */
540 poll_again = FALSE;
541 wait_timeout = 0;
542 }
543 else
544 {
545 poll_again = TRUE;
546 if (timeout == INFTIM)
547 wait_timeout = INFINITE;
548 else
549 wait_timeout = timeout;
550 }
551
552 for (;;)
553 {
554 ret = MsgWaitForMultipleObjects (nhandles, handle_array, FALSE,
555 wait_timeout, QS_ALLINPUT);
556
557 if (ret == WAIT_OBJECT_0 + nhandles)
558 {
559 /* new input of some other kind */
560 BOOL bRet;
561 while ((bRet = PeekMessage (&msg, NULL, 0, 0, PM_REMOVE)) != 0)
562 {
563 TranslateMessage (&msg);
564 DispatchMessage (&msg);
565 }
566 }
567 else
568 break;
569 }
570
571 if (poll_again)
572 select (0, &rfds, &wfds, &xfds, &tv0);
573
574 /* Place a sentinel at the end of the array. */
575 handle_array[nhandles] = NULL;
576 nhandles = 1;
577 for (i = 0; i < nfd; i++)
578 {
579 int happened;
580
581 if (pfd[i].fd < 0)
582 continue;
583 if (!(pfd[i].events & (POLLIN | POLLRDNORM |
584 POLLOUT | POLLWRNORM | POLLWRBAND)))
585 continue;
586
587 h = (HANDLE) _get_osfhandle (pfd[i].fd);
588 if (h != handle_array[nhandles])
589 {
590 /* It's a socket. */
591 WSAEnumNetworkEvents ((SOCKET) h, NULL, &ev);
592 WSAEventSelect ((SOCKET) h, NULL, 0);
593
594 /* If we're lucky, WSAEnumNetworkEvents already provided a way
595 to distinguish FD_READ and FD_ACCEPT; this saves a recv later. */
596 if (FD_ISSET ((SOCKET) h, &rfds)
597 && !(ev.lNetworkEvents & (FD_READ | FD_ACCEPT)))
598 ev.lNetworkEvents |= FD_READ | FD_ACCEPT;
599 if (FD_ISSET ((SOCKET) h, &wfds))
600 ev.lNetworkEvents |= FD_WRITE | FD_CONNECT;
601 if (FD_ISSET ((SOCKET) h, &xfds))
602 ev.lNetworkEvents |= FD_OOB;
603
604 happened = win32_compute_revents_socket ((SOCKET) h, pfd[i].events,
605 ev.lNetworkEvents);
606 }
607 else
608 {
609 /* Not a socket. */
610 int sought = pfd[i].events;
611 happened = win32_compute_revents (h, &sought);
612 nhandles++;
613 }
614
615 if ((pfd[i].revents |= happened) != 0)
616 rc++;
617 }
618
619 if (!rc && orig_timeout && timeout != INFTIM)
620 {
621 ULONGLONG elapsed = GetTickCount64() - start;
622 timeout = elapsed >= orig_timeout ? 0 : (int)(orig_timeout - elapsed);
623 }
624
625 if (!rc && timeout)
626 {
627 SleepEx (1, TRUE);
628 goto restart;
629 }
630
631 return rc;
632 #endif
633 }