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