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