/src/PROJ/curl/lib/select.c

Source (jump to first uncovered line)
/***************************************************************************
 *                                  _   _ ____  _
 *  Project                     ___| | | |  _ \| |
 *                             / __| | | | |_) | |
 *                            | (__| |_| |  _ <| |___
 *                             \___|\___/|_| \_\_____|
 *
 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
 *
 * This software is licensed as described in the file COPYING, which
 * you should have received as part of this distribution. The terms
 * are also available at https://curl.se/docs/copyright.html.
 *
 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
 * copies of the Software, and permit persons to whom the Software is
 * furnished to do so, under the terms of the COPYING file.
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 * KIND, either express or implied.
 *
 * SPDX-License-Identifier: curl
 *
 ***************************************************************************/

#include "curl_setup.h"

#include <limits.h>

#ifdef HAVE_SYS_SELECT_H
#include <sys/select.h>
#elif defined(HAVE_UNISTD_H)
#include <unistd.h>
#endif

#if !defined(HAVE_SELECT) && !defined(HAVE_POLL_FINE)
#error "We can't compile without select() or poll() support."
#endif

#ifdef MSDOS
#include <dos.h>  /* delay() */
#endif

#include <curl/curl.h>

#include "urldata.h"
#include "connect.h"
#include "select.h"
#include "timediff.h"
#include "warnless.h"

/*
 * Internal function used for waiting a specific amount of ms
 * in Curl_socket_check() and Curl_poll() when no file descriptor
 * is provided to wait on, just being used to delay execution.
 * WinSock select() and poll() timeout mechanisms need a valid
 * socket descriptor in a not null file descriptor set to work.
 * Waiting indefinitely with this function is not allowed, a
 * zero or negative timeout value will return immediately.
 * Timeout resolution, accuracy, as well as maximum supported
 * value is system dependent, neither factor is a critical issue
 * for the intended use of this function in the library.
 *
 * Return values:
 *   -1 = system call error, or invalid timeout value
 *    0 = specified timeout has elapsed, or interrupted
 */
int Curl_wait_ms(timediff_t timeout_ms)
{
  int r = 0;

  if(!timeout_ms)
    return 0;
  if(timeout_ms < 0) {
    SET_SOCKERRNO(EINVAL);
    return -1;
  }
#if defined(MSDOS)
  delay(timeout_ms);
#elif defined(_WIN32)
  /* prevent overflow, timeout_ms is typecast to ULONG/DWORD. */
#if TIMEDIFF_T_MAX >= ULONG_MAX
  if(timeout_ms >= ULONG_MAX)
    timeout_ms = ULONG_MAX-1;
    /* don't use ULONG_MAX, because that is equal to INFINITE */
#endif
  Sleep((ULONG)timeout_ms);
#else
#if defined(HAVE_POLL_FINE)
  /* prevent overflow, timeout_ms is typecast to int. */
#if TIMEDIFF_T_MAX > INT_MAX
  if(timeout_ms > INT_MAX)
    timeout_ms = INT_MAX;
#endif
  r = poll(NULL, 0, (int)timeout_ms);
#else
  {
    struct timeval pending_tv;
    r = select(0, NULL, NULL, NULL, curlx_mstotv(&pending_tv, timeout_ms));
  }
#endif /* HAVE_POLL_FINE */
#endif /* USE_WINSOCK */
  if(r) {
    if((r == -1) && (SOCKERRNO == EINTR))
      /* make EINTR from select or poll not a "lethal" error */
      r = 0;
    else
      r = -1;
  }
  return r;
}

#ifndef HAVE_POLL_FINE
/*
 * This is a wrapper around select() to aid in Windows compatibility.
 * A negative timeout value makes this function wait indefinitely,
 * unless no valid file descriptor is given, when this happens the
 * negative timeout is ignored and the function times out immediately.
 *
 * Return values:
 *   -1 = system call error or fd >= FD_SETSIZE
 *    0 = timeout
 *    N = number of signalled file descriptors
 */
static int our_select(curl_socket_t maxfd,   /* highest socket number */
                      fd_set *fds_read,      /* sockets ready for reading */
                      fd_set *fds_write,     /* sockets ready for writing */
                      fd_set *fds_err,       /* sockets with errors */
                      timediff_t timeout_ms) /* milliseconds to wait */
{
  struct timeval pending_tv;
  struct timeval *ptimeout;

#ifdef USE_WINSOCK
  /* WinSock select() can't handle zero events.  See the comment below. */
  if((!fds_read || fds_read->fd_count == 0) &&
     (!fds_write || fds_write->fd_count == 0) &&
     (!fds_err || fds_err->fd_count == 0)) {
    /* no sockets, just wait */
    return Curl_wait_ms(timeout_ms);
  }
#endif

  ptimeout = curlx_mstotv(&pending_tv, timeout_ms);

#ifdef USE_WINSOCK
  /* WinSock select() must not be called with an fd_set that contains zero
    fd flags, or it will return WSAEINVAL.  But, it also can't be called
    with no fd_sets at all!  From the documentation:

    Any two of the parameters, readfds, writefds, or exceptfds, can be
    given as null. At least one must be non-null, and any non-null
    descriptor set must contain at least one handle to a socket.

    It is unclear why WinSock doesn't just handle this for us instead of
    calling this an error. Luckily, with WinSock, we can _also_ ask how
    many bits are set on an fd_set. So, let's just check it beforehand.
  */
  return select((int)maxfd + 1,
                fds_read && fds_read->fd_count ? fds_read : NULL,
                fds_write && fds_write->fd_count ? fds_write : NULL,
                fds_err && fds_err->fd_count ? fds_err : NULL, ptimeout);
#else
  return select((int)maxfd + 1, fds_read, fds_write, fds_err, ptimeout);
#endif
}

#endif

/*
 * Wait for read or write events on a set of file descriptors. It uses poll()
 * when a fine poll() is available, in order to avoid limits with FD_SETSIZE,
 * otherwise select() is used.  An error is returned if select() is being used
 * and a file descriptor is too large for FD_SETSIZE.
 *
 * A negative timeout value makes this function wait indefinitely,
 * unless no valid file descriptor is given, when this happens the
 * negative timeout is ignored and the function times out immediately.
 *
 * Return values:
 *   -1 = system call error or fd >= FD_SETSIZE
 *    0 = timeout
 *    [bitmask] = action as described below
 *
 * CURL_CSELECT_IN - first socket is readable
 * CURL_CSELECT_IN2 - second socket is readable
 * CURL_CSELECT_OUT - write socket is writable
 * CURL_CSELECT_ERR - an error condition occurred
 */
int Curl_socket_check(curl_socket_t readfd0, /* two sockets to read from */
                      curl_socket_t readfd1,
                      curl_socket_t writefd, /* socket to write to */
                      timediff_t timeout_ms) /* milliseconds to wait */
{
  struct pollfd pfd[3];
  int num;
  int r;

  if((readfd0 == CURL_SOCKET_BAD) && (readfd1 == CURL_SOCKET_BAD) &&
     (writefd == CURL_SOCKET_BAD)) {
    /* no sockets, just wait */
    return Curl_wait_ms(timeout_ms);
  }

  /* Avoid initial timestamp, avoid Curl_now() call, when elapsed
     time in this function does not need to be measured. This happens
     when function is called with a zero timeout or a negative timeout
     value indicating a blocking call should be performed. */

  num = 0;
  if(readfd0 != CURL_SOCKET_BAD) {
    pfd[num].fd = readfd0;
    pfd[num].events = POLLRDNORM|POLLIN|POLLRDBAND|POLLPRI;
    pfd[num].revents = 0;
    num++;
  }
  if(readfd1 != CURL_SOCKET_BAD) {
    pfd[num].fd = readfd1;
    pfd[num].events = POLLRDNORM|POLLIN|POLLRDBAND|POLLPRI;
    pfd[num].revents = 0;
    num++;
  }
  if(writefd != CURL_SOCKET_BAD) {
    pfd[num].fd = writefd;
    pfd[num].events = POLLWRNORM|POLLOUT|POLLPRI;
    pfd[num].revents = 0;
    num++;
  }

  r = Curl_poll(pfd, num, timeout_ms);
  if(r <= 0)
    return r;

  r = 0;
  num = 0;
  if(readfd0 != CURL_SOCKET_BAD) {
    if(pfd[num].revents & (POLLRDNORM|POLLIN|POLLERR|POLLHUP))
      r |= CURL_CSELECT_IN;
    if(pfd[num].revents & (POLLPRI|POLLNVAL))
      r |= CURL_CSELECT_ERR;
    num++;
  }
  if(readfd1 != CURL_SOCKET_BAD) {
    if(pfd[num].revents & (POLLRDNORM|POLLIN|POLLERR|POLLHUP))
      r |= CURL_CSELECT_IN2;
    if(pfd[num].revents & (POLLPRI|POLLNVAL))
      r |= CURL_CSELECT_ERR;
    num++;
  }
  if(writefd != CURL_SOCKET_BAD) {
    if(pfd[num].revents & (POLLWRNORM|POLLOUT))
      r |= CURL_CSELECT_OUT;
    if(pfd[num].revents & (POLLERR|POLLHUP|POLLPRI|POLLNVAL))
      r |= CURL_CSELECT_ERR;
  }

  return r;
}

/*
 * This is a wrapper around poll().  If poll() does not exist, then
 * select() is used instead.  An error is returned if select() is
 * being used and a file descriptor is too large for FD_SETSIZE.
 * A negative timeout value makes this function wait indefinitely,
 * unless no valid file descriptor is given, when this happens the
 * negative timeout is ignored and the function times out immediately.
 *
 * Return values:
 *   -1 = system call error or fd >= FD_SETSIZE
 *    0 = timeout
 *    N = number of structures with non zero revent fields
 */
int Curl_poll(struct pollfd ufds[], unsigned int nfds, timediff_t timeout_ms)
{
#ifdef HAVE_POLL_FINE
  int pending_ms;
#else
  fd_set fds_read;
  fd_set fds_write;
  fd_set fds_err;
  curl_socket_t maxfd;
#endif
  bool fds_none = TRUE;
  unsigned int i;
  int r;

  if(ufds) {
    for(i = 0; i < nfds; i++) {
      if(ufds[i].fd != CURL_SOCKET_BAD) {
        fds_none = FALSE;
        break;
      }
    }
  }
  if(fds_none) {
    /* no sockets, just wait */
    return Curl_wait_ms(timeout_ms);
  }

  /* Avoid initial timestamp, avoid Curl_now() call, when elapsed
     time in this function does not need to be measured. This happens
     when function is called with a zero timeout or a negative timeout
     value indicating a blocking call should be performed. */

#ifdef HAVE_POLL_FINE

  /* prevent overflow, timeout_ms is typecast to int. */
#if TIMEDIFF_T_MAX > INT_MAX
  if(timeout_ms > INT_MAX)
    timeout_ms = INT_MAX;
#endif
  if(timeout_ms > 0)
    pending_ms = (int)timeout_ms;
  else if(timeout_ms < 0)
    pending_ms = -1;
  else
    pending_ms = 0;
  r = poll(ufds, nfds, pending_ms);
  if(r <= 0) {
    if((r == -1) && (SOCKERRNO == EINTR))
      /* make EINTR from select or poll not a "lethal" error */
      r = 0;
    return r;
  }

  for(i = 0; i < nfds; i++) {
    if(ufds[i].fd == CURL_SOCKET_BAD)
      continue;
    if(ufds[i].revents & POLLHUP)
      ufds[i].revents |= POLLIN;
    if(ufds[i].revents & POLLERR)
      ufds[i].revents |= POLLIN|POLLOUT;
  }

#else  /* HAVE_POLL_FINE */

  FD_ZERO(&fds_read);
  FD_ZERO(&fds_write);
  FD_ZERO(&fds_err);
  maxfd = (curl_socket_t)-1;

  for(i = 0; i < nfds; i++) {
    ufds[i].revents = 0;
    if(ufds[i].fd == CURL_SOCKET_BAD)
      continue;
    VERIFY_SOCK(ufds[i].fd);
    if(ufds[i].events & (POLLIN|POLLOUT|POLLPRI|
                         POLLRDNORM|POLLWRNORM|POLLRDBAND)) {
      if(ufds[i].fd > maxfd)
        maxfd = ufds[i].fd;
      if(ufds[i].events & (POLLRDNORM|POLLIN))
        FD_SET(ufds[i].fd, &fds_read);
      if(ufds[i].events & (POLLWRNORM|POLLOUT))
        FD_SET(ufds[i].fd, &fds_write);
      if(ufds[i].events & (POLLRDBAND|POLLPRI))
        FD_SET(ufds[i].fd, &fds_err);
    }
  }

  /*
     Note also that WinSock ignores the first argument, so we don't worry
     about the fact that maxfd is computed incorrectly with WinSock (since
     curl_socket_t is unsigned in such cases and thus -1 is the largest
     value).
  */
  r = our_select(maxfd, &fds_read, &fds_write, &fds_err, timeout_ms);
  if(r <= 0) {
    if((r == -1) && (SOCKERRNO == EINTR))
      /* make EINTR from select or poll not a "lethal" error */
      r = 0;
    return r;
  }

  r = 0;
  for(i = 0; i < nfds; i++) {
    ufds[i].revents = 0;
    if(ufds[i].fd == CURL_SOCKET_BAD)
      continue;
    if(FD_ISSET(ufds[i].fd, &fds_read)) {
      if(ufds[i].events & POLLRDNORM)
        ufds[i].revents |= POLLRDNORM;
      if(ufds[i].events & POLLIN)
        ufds[i].revents |= POLLIN;
    }
    if(FD_ISSET(ufds[i].fd, &fds_write)) {
      if(ufds[i].events & POLLWRNORM)
        ufds[i].revents |= POLLWRNORM;
      if(ufds[i].events & POLLOUT)
        ufds[i].revents |= POLLOUT;
    }
    if(FD_ISSET(ufds[i].fd, &fds_err)) {
      if(ufds[i].events & POLLRDBAND)
        ufds[i].revents |= POLLRDBAND;
      if(ufds[i].events & POLLPRI)
        ufds[i].revents |= POLLPRI;
    }
    if(ufds[i].revents)
      r++;
  }

#endif  /* HAVE_POLL_FINE */

  return r;
}

Coverage Report

Created: 2024-02-25 06:14

Line	Count	Source (jump to first uncovered line)
1		/***************************************************************************
2		* _ _ ____ _
3		* Project ___\| \| \| \| _ \\| \|
4		* / __\| \| \| \| \|_) \| \|
5		* \| (__\| \|_\| \| _ <\| \|___
6		* \___\|\___/\|_\| \_\_____\|
7		*
8		* Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
9		*
10		* This software is licensed as described in the file COPYING, which
11		* you should have received as part of this distribution. The terms
12		* are also available at https://curl.se/docs/copyright.html.
13		*
14		* You may opt to use, copy, modify, merge, publish, distribute and/or sell
15		* copies of the Software, and permit persons to whom the Software is
16		* furnished to do so, under the terms of the COPYING file.
17		*
18		* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19		* KIND, either express or implied.
20		*
21		* SPDX-License-Identifier: curl
22		*
23		***************************************************************************/
24
25		#include "curl_setup.h"
26
27		#include <limits.h>
28
29		#ifdef HAVE_SYS_SELECT_H
30		#include <sys/select.h>
31		#elif defined(HAVE_UNISTD_H)
32		#include <unistd.h>
33		#endif
34
35		#if !defined(HAVE_SELECT) && !defined(HAVE_POLL_FINE)
36		#error "We can't compile without select() or poll() support."
37		#endif
38
39		#ifdef MSDOS
40		#include <dos.h> /* delay() */
41		#endif
42
43		#include <curl/curl.h>
44
45		#include "urldata.h"
46		#include "connect.h"
47		#include "select.h"
48		#include "timediff.h"
49		#include "warnless.h"
50
51		/*
52		* Internal function used for waiting a specific amount of ms
53		* in Curl_socket_check() and Curl_poll() when no file descriptor
54		* is provided to wait on, just being used to delay execution.
55		* WinSock select() and poll() timeout mechanisms need a valid
56		* socket descriptor in a not null file descriptor set to work.
57		* Waiting indefinitely with this function is not allowed, a
58		* zero or negative timeout value will return immediately.
59		* Timeout resolution, accuracy, as well as maximum supported
60		* value is system dependent, neither factor is a critical issue
61		* for the intended use of this function in the library.
62		*
63		* Return values:
64		* -1 = system call error, or invalid timeout value
65		* 0 = specified timeout has elapsed, or interrupted
66		*/
67		int Curl_wait_ms(timediff_t timeout_ms)
68	0	{
69	0	int r = 0;
70
71	0	if(!timeout_ms)
72	0	return 0;
73	0	if(timeout_ms < 0) {
74	0	SET_SOCKERRNO(EINVAL);
75	0	return -1;
76	0	}
77		#if defined(MSDOS)
78		delay(timeout_ms);
79		#elif defined(_WIN32)
80		/* prevent overflow, timeout_ms is typecast to ULONG/DWORD. */
81		#if TIMEDIFF_T_MAX >= ULONG_MAX
82		if(timeout_ms >= ULONG_MAX)
83		timeout_ms = ULONG_MAX-1;
84		/* don't use ULONG_MAX, because that is equal to INFINITE */
85		#endif
86		Sleep((ULONG)timeout_ms);
87		#else
88	0	#if defined(HAVE_POLL_FINE)
89		/* prevent overflow, timeout_ms is typecast to int. */
90	0	#if TIMEDIFF_T_MAX > INT_MAX
91	0	if(timeout_ms > INT_MAX)
92	0	timeout_ms = INT_MAX;
93	0	#endif
94	0	r = poll(NULL, 0, (int)timeout_ms);
95		#else
96		{
97		struct timeval pending_tv;
98		r = select(0, NULL, NULL, NULL, curlx_mstotv(&pending_tv, timeout_ms));
99		}
100		#endif /* HAVE_POLL_FINE */
101	0	#endif /* USE_WINSOCK */
102	0	if(r) {
103	0	if((r == -1) && (SOCKERRNO == EINTR))
104		/* make EINTR from select or poll not a "lethal" error */
105	0	r = 0;
106	0	else
107	0	r = -1;
108	0	}
109	0	return r;
110	0	}
111
112		#ifndef HAVE_POLL_FINE
113		/*
114		* This is a wrapper around select() to aid in Windows compatibility.
115		* A negative timeout value makes this function wait indefinitely,
116		* unless no valid file descriptor is given, when this happens the
117		* negative timeout is ignored and the function times out immediately.
118		*
119		* Return values:
120		* -1 = system call error or fd >= FD_SETSIZE
121		* 0 = timeout
122		* N = number of signalled file descriptors
123		*/
124		static int our_select(curl_socket_t maxfd, /* highest socket number */
125		fd_set fds_read, / sockets ready for reading */
126		fd_set fds_write, / sockets ready for writing */
127		fd_set fds_err, / sockets with errors */
128		timediff_t timeout_ms) /* milliseconds to wait */
129		{
130		struct timeval pending_tv;
131		struct timeval *ptimeout;
132
133		#ifdef USE_WINSOCK
134		/* WinSock select() can't handle zero events. See the comment below. */
135		if((!fds_read \|\| fds_read->fd_count == 0) &&
136		(!fds_write \|\| fds_write->fd_count == 0) &&
137		(!fds_err \|\| fds_err->fd_count == 0)) {
138		/* no sockets, just wait */
139		return Curl_wait_ms(timeout_ms);
140		}
141		#endif
142
143		ptimeout = curlx_mstotv(&pending_tv, timeout_ms);
144
145		#ifdef USE_WINSOCK
146		/* WinSock select() must not be called with an fd_set that contains zero
147		fd flags, or it will return WSAEINVAL. But, it also can't be called
148		with no fd_sets at all! From the documentation:
149
150		Any two of the parameters, readfds, writefds, or exceptfds, can be
151		given as null. At least one must be non-null, and any non-null
152		descriptor set must contain at least one handle to a socket.
153
154		It is unclear why WinSock doesn't just handle this for us instead of
155		calling this an error. Luckily, with WinSock, we can _also_ ask how
156		many bits are set on an fd_set. So, let's just check it beforehand.
157		*/
158		return select((int)maxfd + 1,
159		fds_read && fds_read->fd_count ? fds_read : NULL,
160		fds_write && fds_write->fd_count ? fds_write : NULL,
161		fds_err && fds_err->fd_count ? fds_err : NULL, ptimeout);
162		#else
163		return select((int)maxfd + 1, fds_read, fds_write, fds_err, ptimeout);
164		#endif
165		}
166
167		#endif
168
169		/*
170		* Wait for read or write events on a set of file descriptors. It uses poll()
171		* when a fine poll() is available, in order to avoid limits with FD_SETSIZE,
172		* otherwise select() is used. An error is returned if select() is being used
173		* and a file descriptor is too large for FD_SETSIZE.
174		*
175		* A negative timeout value makes this function wait indefinitely,
176		* unless no valid file descriptor is given, when this happens the
177		* negative timeout is ignored and the function times out immediately.
178		*
179		* Return values:
180		* -1 = system call error or fd >= FD_SETSIZE
181		* 0 = timeout
182		* [bitmask] = action as described below
183		*
184		* CURL_CSELECT_IN - first socket is readable
185		* CURL_CSELECT_IN2 - second socket is readable
186		* CURL_CSELECT_OUT - write socket is writable
187		* CURL_CSELECT_ERR - an error condition occurred
188		*/
189		int Curl_socket_check(curl_socket_t readfd0, /* two sockets to read from */
190		curl_socket_t readfd1,
191		curl_socket_t writefd, /* socket to write to */
192		timediff_t timeout_ms) /* milliseconds to wait */
193	0	{
194	0	struct pollfd pfd[3];
195	0	int num;
196	0	int r;
197
198	0	if((readfd0 == CURL_SOCKET_BAD) && (readfd1 == CURL_SOCKET_BAD) &&
199	0	(writefd == CURL_SOCKET_BAD)) {
200		/* no sockets, just wait */
201	0	return Curl_wait_ms(timeout_ms);
202	0	}
203
204		/* Avoid initial timestamp, avoid Curl_now() call, when elapsed
205		time in this function does not need to be measured. This happens
206		when function is called with a zero timeout or a negative timeout
207		value indicating a blocking call should be performed. */
208
209	0	num = 0;
210	0	if(readfd0 != CURL_SOCKET_BAD) {
211	0	pfd[num].fd = readfd0;
212	0	pfd[num].events = POLLRDNORM\|POLLIN\|POLLRDBAND\|POLLPRI;
213	0	pfd[num].revents = 0;
214	0	num++;
215	0	}
216	0	if(readfd1 != CURL_SOCKET_BAD) {
217	0	pfd[num].fd = readfd1;
218	0	pfd[num].events = POLLRDNORM\|POLLIN\|POLLRDBAND\|POLLPRI;
219	0	pfd[num].revents = 0;
220	0	num++;
221	0	}
222	0	if(writefd != CURL_SOCKET_BAD) {
223	0	pfd[num].fd = writefd;
224	0	pfd[num].events = POLLWRNORM\|POLLOUT\|POLLPRI;
225	0	pfd[num].revents = 0;
226	0	num++;
227	0	}
228
229	0	r = Curl_poll(pfd, num, timeout_ms);
230	0	if(r <= 0)
231	0	return r;
232
233	0	r = 0;
234	0	num = 0;
235	0	if(readfd0 != CURL_SOCKET_BAD) {
236	0	if(pfd[num].revents & (POLLRDNORM\|POLLIN\|POLLERR\|POLLHUP))
237	0	r \|= CURL_CSELECT_IN;
238	0	if(pfd[num].revents & (POLLPRI\|POLLNVAL))
239	0	r \|= CURL_CSELECT_ERR;
240	0	num++;
241	0	}
242	0	if(readfd1 != CURL_SOCKET_BAD) {
243	0	if(pfd[num].revents & (POLLRDNORM\|POLLIN\|POLLERR\|POLLHUP))
244	0	r \|= CURL_CSELECT_IN2;
245	0	if(pfd[num].revents & (POLLPRI\|POLLNVAL))
246	0	r \|= CURL_CSELECT_ERR;
247	0	num++;
248	0	}
249	0	if(writefd != CURL_SOCKET_BAD) {
250	0	if(pfd[num].revents & (POLLWRNORM\|POLLOUT))
251	0	r \|= CURL_CSELECT_OUT;
252	0	if(pfd[num].revents & (POLLERR\|POLLHUP\|POLLPRI\|POLLNVAL))
253	0	r \|= CURL_CSELECT_ERR;
254	0	}
255
256	0	return r;
257	0	}
258
259		/*
260		* This is a wrapper around poll(). If poll() does not exist, then
261		* select() is used instead. An error is returned if select() is
262		* being used and a file descriptor is too large for FD_SETSIZE.
263		* A negative timeout value makes this function wait indefinitely,
264		* unless no valid file descriptor is given, when this happens the
265		* negative timeout is ignored and the function times out immediately.
266		*
267		* Return values:
268		* -1 = system call error or fd >= FD_SETSIZE
269		* 0 = timeout
270		* N = number of structures with non zero revent fields
271		*/
272		int Curl_poll(struct pollfd ufds[], unsigned int nfds, timediff_t timeout_ms)
273	0	{
274	0	#ifdef HAVE_POLL_FINE
275	0	int pending_ms;
276		#else
277		fd_set fds_read;
278		fd_set fds_write;
279		fd_set fds_err;
280		curl_socket_t maxfd;
281		#endif
282	0	bool fds_none = TRUE;
283	0	unsigned int i;
284	0	int r;
285
286	0	if(ufds) {
287	0	for(i = 0; i < nfds; i++) {
288	0	if(ufds[i].fd != CURL_SOCKET_BAD) {
289	0	fds_none = FALSE;
290	0	break;
291	0	}
292	0	}
293	0	}
294	0	if(fds_none) {
295		/* no sockets, just wait */
296	0	return Curl_wait_ms(timeout_ms);
297	0	}
298
299		/* Avoid initial timestamp, avoid Curl_now() call, when elapsed
300		time in this function does not need to be measured. This happens
301		when function is called with a zero timeout or a negative timeout
302		value indicating a blocking call should be performed. */
303
304	0	#ifdef HAVE_POLL_FINE
305
306		/* prevent overflow, timeout_ms is typecast to int. */
307	0	#if TIMEDIFF_T_MAX > INT_MAX
308	0	if(timeout_ms > INT_MAX)
309	0	timeout_ms = INT_MAX;
310	0	#endif
311	0	if(timeout_ms > 0)
312	0	pending_ms = (int)timeout_ms;
313	0	else if(timeout_ms < 0)
314	0	pending_ms = -1;
315	0	else
316	0	pending_ms = 0;
317	0	r = poll(ufds, nfds, pending_ms);
318	0	if(r <= 0) {
319	0	if((r == -1) && (SOCKERRNO == EINTR))
320		/* make EINTR from select or poll not a "lethal" error */
321	0	r = 0;
322	0	return r;
323	0	}
324
325	0	for(i = 0; i < nfds; i++) {
326	0	if(ufds[i].fd == CURL_SOCKET_BAD)
327	0	continue;
328	0	if(ufds[i].revents & POLLHUP)
329	0	ufds[i].revents \|= POLLIN;
330	0	if(ufds[i].revents & POLLERR)
331	0	ufds[i].revents \|= POLLIN\|POLLOUT;
332	0	}
333
334		#else /* HAVE_POLL_FINE */
335
336		FD_ZERO(&fds_read);
337		FD_ZERO(&fds_write);
338		FD_ZERO(&fds_err);
339		maxfd = (curl_socket_t)-1;
340
341		for(i = 0; i < nfds; i++) {
342		ufds[i].revents = 0;
343		if(ufds[i].fd == CURL_SOCKET_BAD)
344		continue;
345		VERIFY_SOCK(ufds[i].fd);
346		if(ufds[i].events & (POLLIN\|POLLOUT\|POLLPRI\|
347		POLLRDNORM\|POLLWRNORM\|POLLRDBAND)) {
348		if(ufds[i].fd > maxfd)
349		maxfd = ufds[i].fd;
350		if(ufds[i].events & (POLLRDNORM\|POLLIN))
351		FD_SET(ufds[i].fd, &fds_read);
352		if(ufds[i].events & (POLLWRNORM\|POLLOUT))
353		FD_SET(ufds[i].fd, &fds_write);
354		if(ufds[i].events & (POLLRDBAND\|POLLPRI))
355		FD_SET(ufds[i].fd, &fds_err);
356		}
357		}
358
359		/*
360		Note also that WinSock ignores the first argument, so we don't worry
361		about the fact that maxfd is computed incorrectly with WinSock (since
362		curl_socket_t is unsigned in such cases and thus -1 is the largest
363		value).
364		*/
365		r = our_select(maxfd, &fds_read, &fds_write, &fds_err, timeout_ms);
366		if(r <= 0) {
367		if((r == -1) && (SOCKERRNO == EINTR))
368		/* make EINTR from select or poll not a "lethal" error */
369		r = 0;
370		return r;
371		}
372
373		r = 0;
374		for(i = 0; i < nfds; i++) {
375		ufds[i].revents = 0;
376		if(ufds[i].fd == CURL_SOCKET_BAD)
377		continue;
378		if(FD_ISSET(ufds[i].fd, &fds_read)) {
379		if(ufds[i].events & POLLRDNORM)
380		ufds[i].revents \|= POLLRDNORM;
381		if(ufds[i].events & POLLIN)
382		ufds[i].revents \|= POLLIN;
383		}
384		if(FD_ISSET(ufds[i].fd, &fds_write)) {
385		if(ufds[i].events & POLLWRNORM)
386		ufds[i].revents \|= POLLWRNORM;
387		if(ufds[i].events & POLLOUT)
388		ufds[i].revents \|= POLLOUT;
389		}
390		if(FD_ISSET(ufds[i].fd, &fds_err)) {
391		if(ufds[i].events & POLLRDBAND)
392		ufds[i].revents \|= POLLRDBAND;
393		if(ufds[i].events & POLLPRI)
394		ufds[i].revents \|= POLLPRI;
395		}
396		if(ufds[i].revents)
397		r++;
398		}
399
400		#endif /* HAVE_POLL_FINE */
401
402	0	return r;
403	0	}