git.oblomov.eu Git - git/blob - 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
 143   switch (GetFileType (h))
 144     {
 145     case FILE_TYPE_PIPE:
 146       happened = 0;
 147       if (PeekNamedPipe (h, NULL, 0, NULL, &avail, NULL) != 0)
 148         {
 149           if (avail)
 150             happened |= *p_sought & (POLLIN | POLLRDNORM);
 151         }
 152       else if (GetLastError () == ERROR_BROKEN_PIPE)
 153         happened |= POLLHUP;
 154
 155       else
 156         {
 157           /* It was the write-end of the pipe. Unfortunately there is no
 158              reliable way of knowing if it can be written without blocking.
 159              Just say that it's all good. */
 160             happened |= *p_sought & (POLLOUT | POLLWRNORM | POLLWRBAND);
 161         }
 162       return happened;
 163
 164     case FILE_TYPE_CHAR:
 165       ret = WaitForSingleObject (h, 0);
 166       if (!IsConsoleHandle (h))
 167         return ret == WAIT_OBJECT_0 ? *p_sought & ~(POLLPRI | POLLRDBAND) : 0;
 168
 169       nbuffer = avail = 0;
 170       bRet = GetNumberOfConsoleInputEvents (h, &nbuffer);
 171       if (bRet)
 172         {
 173           /* Input buffer.  */
 174           *p_sought &= POLLIN | POLLRDNORM;
 175           if (nbuffer == 0)
 176             return POLLHUP;
 177           if (!*p_sought)
 178             return 0;
 179
 180           irbuffer = (INPUT_RECORD *) alloca (nbuffer * sizeof (INPUT_RECORD));
 181           bRet = PeekConsoleInput (h, irbuffer, nbuffer, &avail);
 182           if (!bRet || avail == 0)
 183             return POLLHUP;
 184
 185           for (i = 0; i < avail; i++)
 186             if (irbuffer[i].EventType == KEY_EVENT)
 187               return *p_sought;
 188           return 0;
 189         }
 190       else
 191         {
 192           /* Screen buffer.  */
 193           *p_sought &= POLLOUT | POLLWRNORM | POLLWRBAND;
 194           return *p_sought;
 195         }
 196
 197     default:
 198       ret = WaitForSingleObject (h, 0);
 199       if (ret == WAIT_OBJECT_0)
 200         return *p_sought & ~(POLLPRI | POLLRDBAND);
 201
 202       return *p_sought & (POLLOUT | POLLWRNORM | POLLWRBAND);
 203     }
 204 }
 205
 206 /* Convert fd_sets returned by select into revents values.  */
 207
 208 static int
 209 win32_compute_revents_socket (SOCKET h, int sought, long lNetworkEvents)
 210 {
 211   int happened = 0;
 212
 213   if ((lNetworkEvents & (FD_READ | FD_ACCEPT | FD_CLOSE)) == FD_ACCEPT)
 214     happened |= (POLLIN | POLLRDNORM) & sought;
 215
 216   else if (lNetworkEvents & (FD_READ | FD_ACCEPT | FD_CLOSE))
 217     {
 218       int r, error;
 219
 220       char data[64];
 221       WSASetLastError (0);
 222       r = recv (h, data, sizeof (data), MSG_PEEK);
 223       error = WSAGetLastError ();
 224       WSASetLastError (0);
 225
 226       if (r > 0 || error == WSAENOTCONN)
 227         happened |= (POLLIN | POLLRDNORM) & sought;
 228
 229       /* Distinguish hung-up sockets from other errors.  */
 230       else if (r == 0 || error == WSAESHUTDOWN || error == WSAECONNRESET
 231                || error == WSAECONNABORTED || error == WSAENETRESET)
 232         happened |= POLLHUP;
 233
 234       else
 235         happened |= POLLERR;
 236     }
 237
 238   if (lNetworkEvents & (FD_WRITE | FD_CONNECT))
 239     happened |= (POLLOUT | POLLWRNORM | POLLWRBAND) & sought;
 240
 241   if (lNetworkEvents & FD_OOB)
 242     happened |= (POLLPRI | POLLRDBAND) & sought;
 243
 244   return happened;
 245 }
 246
 247 #else /* !MinGW */
 248
 249 /* Convert select(2) returned fd_sets into poll(2) revents values.  */
 250 static int
 251 compute_revents (int fd, int sought, fd_set *rfds, fd_set *wfds, fd_set *efds)
 252 {
 253   int happened = 0;
 254   if (FD_ISSET (fd, rfds))
 255     {
 256       int r;
 257       int socket_errno;
 258
 259 # if defined __MACH__ && defined __APPLE__
 260       /* There is a bug in Mac OS X that causes it to ignore MSG_PEEK
 261          for some kinds of descriptors.  Detect if this descriptor is a
 262          connected socket, a server socket, or something else using a
 263          0-byte recv, and use ioctl(2) to detect POLLHUP.  */
 264       r = recv (fd, NULL, 0, MSG_PEEK);
 265       socket_errno = (r < 0) ? errno : 0;
 266       if (r == 0 || socket_errno == ENOTSOCK)
 267         ioctl (fd, FIONREAD, &r);
 268 # else
 269       char data[64];
 270       r = recv (fd, data, sizeof (data), MSG_PEEK);
 271       socket_errno = (r < 0) ? errno : 0;
 272 # endif
 273       if (r == 0)
 274         happened |= POLLHUP;
 275
 276       /* If the event happened on an unconnected server socket,
 277          that's fine. */
 278       else if (r > 0 || ( /* (r == -1) && */ socket_errno == ENOTCONN))
 279         happened |= (POLLIN | POLLRDNORM) & sought;
 280
 281       /* Distinguish hung-up sockets from other errors.  */
 282       else if (socket_errno == ESHUTDOWN || socket_errno == ECONNRESET
 283                || socket_errno == ECONNABORTED || socket_errno == ENETRESET)
 284         happened |= POLLHUP;
 285
 286       /* some systems can't use recv() on non-socket, including HP NonStop */
 287       else if (/* (r == -1) && */ socket_errno == ENOTSOCK)
 288         happened |= (POLLIN | POLLRDNORM) & sought;
 289
 290       else
 291         happened |= POLLERR;
 292     }
 293
 294   if (FD_ISSET (fd, wfds))
 295     happened |= (POLLOUT | POLLWRNORM | POLLWRBAND) & sought;
 296
 297   if (FD_ISSET (fd, efds))
 298     happened |= (POLLPRI | POLLRDBAND) & sought;
 299
 300   return happened;
 301 }
 302 #endif /* !MinGW */
 303
 304 int
 305 poll (struct pollfd *pfd, nfds_t nfd, int timeout)
 306 {
 307 #ifndef WIN32_NATIVE
 308   fd_set rfds, wfds, efds;
 309   struct timeval tv;
 310   struct timeval *ptv;
 311   int maxfd, rc;
 312   nfds_t i;
 313
 314 # ifdef _SC_OPEN_MAX
 315   static int sc_open_max = -1;
 316
 317   if (nfd < 0
 318       || (nfd > sc_open_max
 319           && (sc_open_max != -1
 320               || nfd > (sc_open_max = sysconf (_SC_OPEN_MAX)))))
 321     {
 322       errno = EINVAL;
 323       return -1;
 324     }
 325 # else /* !_SC_OPEN_MAX */
 326 #  ifdef OPEN_MAX
 327   if (nfd < 0 || nfd > OPEN_MAX)
 328     {
 329       errno = EINVAL;
 330       return -1;
 331     }
 332 #  endif /* OPEN_MAX -- else, no check is needed */
 333 # endif /* !_SC_OPEN_MAX */
 334
 335   /* EFAULT is not necessary to implement, but let's do it in the
 336      simplest case. */
 337   if (!pfd && nfd)
 338     {
 339       errno = EFAULT;
 340       return -1;
 341     }
 342
 343   /* convert timeout number into a timeval structure */
 344   if (timeout == 0)
 345     {
 346       ptv = &tv;
 347       ptv->tv_sec = 0;
 348       ptv->tv_usec = 0;
 349     }
 350   else if (timeout > 0)
 351     {
 352       ptv = &tv;
 353       ptv->tv_sec = timeout / 1000;
 354       ptv->tv_usec = (timeout % 1000) * 1000;
 355     }
 356   else if (timeout == INFTIM)
 357     /* wait forever */
 358     ptv = NULL;
 359   else
 360     {
 361       errno = EINVAL;
 362       return -1;
 363     }
 364
 365   /* create fd sets and determine max fd */
 366   maxfd = -1;
 367   FD_ZERO (&rfds);
 368   FD_ZERO (&wfds);
 369   FD_ZERO (&efds);
 370   for (i = 0; i < nfd; i++)
 371     {
 372       if (pfd[i].fd < 0)
 373         continue;
 374
 375       if (pfd[i].events & (POLLIN | POLLRDNORM))
 376         FD_SET (pfd[i].fd, &rfds);
 377
 378       /* see select(2): "the only exceptional condition detectable
 379          is out-of-band data received on a socket", hence we push
 380          POLLWRBAND events onto wfds instead of efds. */
 381       if (pfd[i].events & (POLLOUT | POLLWRNORM | POLLWRBAND))
 382         FD_SET (pfd[i].fd, &wfds);
 383       if (pfd[i].events & (POLLPRI | POLLRDBAND))
 384         FD_SET (pfd[i].fd, &efds);
 385       if (pfd[i].fd >= maxfd
 386           && (pfd[i].events & (POLLIN | POLLOUT | POLLPRI
 387                                | POLLRDNORM | POLLRDBAND
 388                                | POLLWRNORM | POLLWRBAND)))
 389         {
 390           maxfd = pfd[i].fd;
 391           if (maxfd > FD_SETSIZE)
 392             {
 393               errno = EOVERFLOW;
 394               return -1;
 395             }
 396         }
 397     }
 398
 399   /* examine fd sets */
 400   rc = select (maxfd + 1, &rfds, &wfds, &efds, ptv);
 401   if (rc < 0)
 402     return rc;
 403
 404   /* establish results */
 405   rc = 0;
 406   for (i = 0; i < nfd; i++)
 407     if (pfd[i].fd < 0)
 408       pfd[i].revents = 0;
 409     else
 410       {
 411         int happened = compute_revents (pfd[i].fd, pfd[i].events,
 412                                         &rfds, &wfds, &efds);
 413         if (happened)
 414           {
 415             pfd[i].revents = happened;
 416             rc++;
 417           }
 418         else
 419           {
 420             pfd[i].revents = 0;
 421           }
 422       }
 423
 424   return rc;
 425 #else
 426   static struct timeval tv0;
 427   static HANDLE hEvent;
 428   WSANETWORKEVENTS ev;
 429   HANDLE h, handle_array[FD_SETSIZE + 2];
 430   DWORD ret, wait_timeout, nhandles, orig_timeout = 0;
 431   ULONGLONG start = 0;
 432   fd_set rfds, wfds, xfds;
 433   BOOL poll_again;
 434   MSG msg;
 435   int rc = 0;
 436   nfds_t i;
 437
 438   if (nfd < 0 || timeout < -1)
 439     {
 440       errno = EINVAL;
 441       return -1;
 442     }
 443
 444   if (timeout != INFTIM)
 445     {
 446       orig_timeout = timeout;
 447       start = GetTickCount64();
 448     }
 449
 450   if (!hEvent)
 451     hEvent = CreateEvent (NULL, FALSE, FALSE, NULL);
 452
 453 restart:
 454   handle_array[0] = hEvent;
 455   nhandles = 1;
 456   FD_ZERO (&rfds);
 457   FD_ZERO (&wfds);
 458   FD_ZERO (&xfds);
 459
 460   /* Classify socket handles and create fd sets. */
 461   for (i = 0; i < nfd; i++)
 462     {
 463       int sought = pfd[i].events;
 464       pfd[i].revents = 0;
 465       if (pfd[i].fd < 0)
 466         continue;
 467       if (!(sought & (POLLIN | POLLRDNORM | POLLOUT | POLLWRNORM | POLLWRBAND
 468                       | POLLPRI | POLLRDBAND)))
 469         continue;
 470
 471       h = (HANDLE) _get_osfhandle (pfd[i].fd);
 472       assert (h != NULL);
 473       if (IsSocketHandle (h))
 474         {
 475           int requested = FD_CLOSE;
 476
 477           /* see above; socket handles are mapped onto select.  */
 478           if (sought & (POLLIN | POLLRDNORM))
 479             {
 480               requested |= FD_READ | FD_ACCEPT;
 481               FD_SET ((SOCKET) h, &rfds);
 482             }
 483           if (sought & (POLLOUT | POLLWRNORM | POLLWRBAND))
 484             {
 485               requested |= FD_WRITE | FD_CONNECT;
 486               FD_SET ((SOCKET) h, &wfds);
 487             }
 488           if (sought & (POLLPRI | POLLRDBAND))
 489             {
 490               requested |= FD_OOB;
 491               FD_SET ((SOCKET) h, &xfds);
 492             }
 493
 494           if (requested)
 495             WSAEventSelect ((SOCKET) h, hEvent, requested);
 496         }
 497       else
 498         {
 499           /* Poll now.  If we get an event, do not poll again.  Also,
 500              screen buffer handles are waitable, and they'll block until
 501              a character is available.  win32_compute_revents eliminates
 502              bits for the "wrong" direction. */
 503           pfd[i].revents = win32_compute_revents (h, &sought);
 504           if (sought)
 505             handle_array[nhandles++] = h;
 506           if (pfd[i].revents)
 507             timeout = 0;
 508         }
 509     }
 510
 511   if (select (0, &rfds, &wfds, &xfds, &tv0) > 0)
 512     {
 513       /* Do MsgWaitForMultipleObjects anyway to dispatch messages, but
 514          no need to call select again.  */
 515       poll_again = FALSE;
 516       wait_timeout = 0;
 517     }
 518   else
 519     {
 520       poll_again = TRUE;
 521       if (timeout == INFTIM)
 522         wait_timeout = INFINITE;
 523       else
 524         wait_timeout = timeout;
 525     }
 526
 527   for (;;)
 528     {
 529       ret = MsgWaitForMultipleObjects (nhandles, handle_array, FALSE,
 530                                        wait_timeout, QS_ALLINPUT);
 531
 532       if (ret == WAIT_OBJECT_0 + nhandles)
 533         {
 534           /* new input of some other kind */
 535           BOOL bRet;
 536           while ((bRet = PeekMessage (&msg, NULL, 0, 0, PM_REMOVE)) != 0)
 537             {
 538               TranslateMessage (&msg);
 539               DispatchMessage (&msg);
 540             }
 541         }
 542       else
 543         break;
 544     }
 545
 546   if (poll_again)
 547     select (0, &rfds, &wfds, &xfds, &tv0);
 548
 549   /* Place a sentinel at the end of the array.  */
 550   handle_array[nhandles] = NULL;
 551   nhandles = 1;
 552   for (i = 0; i < nfd; i++)
 553     {
 554       int happened;
 555
 556       if (pfd[i].fd < 0)
 557         continue;
 558       if (!(pfd[i].events & (POLLIN | POLLRDNORM |
 559                              POLLOUT | POLLWRNORM | POLLWRBAND)))
 560         continue;
 561
 562       h = (HANDLE) _get_osfhandle (pfd[i].fd);
 563       if (h != handle_array[nhandles])
 564         {
 565           /* It's a socket.  */
 566           WSAEnumNetworkEvents ((SOCKET) h, NULL, &ev);
 567           WSAEventSelect ((SOCKET) h, NULL, 0);
 568
 569           /* If we're lucky, WSAEnumNetworkEvents already provided a way
 570              to distinguish FD_READ and FD_ACCEPT; this saves a recv later.  */
 571           if (FD_ISSET ((SOCKET) h, &rfds)
 572               && !(ev.lNetworkEvents & (FD_READ | FD_ACCEPT)))
 573             ev.lNetworkEvents |= FD_READ | FD_ACCEPT;
 574           if (FD_ISSET ((SOCKET) h, &wfds))
 575             ev.lNetworkEvents |= FD_WRITE | FD_CONNECT;
 576           if (FD_ISSET ((SOCKET) h, &xfds))
 577             ev.lNetworkEvents |= FD_OOB;
 578
 579           happened = win32_compute_revents_socket ((SOCKET) h, pfd[i].events,
 580                                                    ev.lNetworkEvents);
 581         }
 582       else
 583         {
 584           /* Not a socket.  */
 585           int sought = pfd[i].events;
 586           happened = win32_compute_revents (h, &sought);
 587           nhandles++;
 588         }
 589
 590        if ((pfd[i].revents |= happened) != 0)
 591         rc++;
 592     }
 593
 594   if (!rc && orig_timeout && timeout != INFTIM)
 595     {
 596       ULONGLONG elapsed = GetTickCount64() - start;
 597       timeout = elapsed >= orig_timeout ? 0 : (int)(orig_timeout - elapsed);
 598     }
 599
 600   if (!rc && timeout)
 601     {
 602       SleepEx (1, TRUE);
 603       goto restart;
 604     }
 605
 606   return rc;
 607 #endif
 608 }