10242

pending completion

Build # 10242

Build Type

Pull #3718

travis-ci

Committed by

web-flow

Commit Message

tool_cb_wrt: fix bad-function-cast warning

Commit f5bc578f4 reintroduced the
warning fixed in commit 2f5f31bb5.
Extend fhnd's scope and reuse that variable instead of calling
_get_osfhandle a second time to fix the warning again.

Closes

Pull Request Pull Request #3718: tool_cb_wrt: fix bad-function-cast warning

Run Details

22109 of 29024 relevant lines covered (76.17%)

751546.14 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

74.62

/lib/select.c

/***************************************************************************
 *                                  _   _ ____  _
 *  Project                     ___| | | |  _ \| |
 *                             / __| | | | |_) | |
 *                            | (__| |_| |  _ <| |___
 *                             \___|\___/|_| \_\_____|
 *
 * Copyright (C) 1998 - 2017, 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.haxx.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.
 *
 ***************************************************************************/

#include "curl_setup.h"

#ifdef HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif

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

#if defined(__BEOS__) && !defined(__HAIKU__)
/* BeOS has FD_SET defined in socket.h */
#include <socket.h>
#endif

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

#ifdef __VXWORKS__
#include <strings.h>  /* bzero() in FD_SET */
#endif

#include <curl/curl.h>

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

/* Convenience local macros */
#define ELAPSED_MS() (int)Curl_timediff(Curl_now(), initial_tv)

int Curl_ack_eintr = 0;
#define ERROR_NOT_EINTR(error) (Curl_ack_eintr || error != EINTR)

/*
 * 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 citical issue
 * for the intended use of this function in the library.
 *
 * Return values:
 *   -1 = system call error, invalid timeout value, or interrupted
 *    0 = specified timeout has elapsed
 */
int Curl_wait_ms(int timeout_ms)
{
#if !defined(MSDOS) && !defined(USE_WINSOCK)
#ifndef HAVE_POLL_FINE
  struct timeval pending_tv;
#endif
  struct curltime initial_tv;
  int pending_ms;
#endif
  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(USE_WINSOCK)
  Sleep(timeout_ms);
#else
  pending_ms = timeout_ms;
  initial_tv = Curl_now();
  do {
    int error;
#if defined(HAVE_POLL_FINE)
    r = poll(NULL, 0, pending_ms);
#else
    pending_tv.tv_sec = pending_ms / 1000;
    pending_tv.tv_usec = (pending_ms % 1000) * 1000;
    r = select(0, NULL, NULL, NULL, &pending_tv);
#endif /* HAVE_POLL_FINE */
    if(r != -1)
      break;
    error = SOCKERRNO;
    if(error && ERROR_NOT_EINTR(error))
      break;
    pending_ms = timeout_ms - ELAPSED_MS();
    if(pending_ms <= 0) {
      r = 0;  /* Simulate a "call timed out" case */
      break;
    }
  } while(r == -1);
#endif /* USE_WINSOCK */
  if(r)
    r = -1;
  return r;
}

/*
 * 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 */
                      time_t timeout_ms)     /* milliseconds to wait */
{
#ifdef HAVE_POLL_FINE
  struct pollfd pfd[3];
  int num;
#else
  struct timeval pending_tv;
  struct timeval *ptimeout;
  fd_set fds_read;
  fd_set fds_write;
  fd_set fds_err;
  curl_socket_t maxfd;
#endif
  struct curltime initial_tv = {0, 0};
  int pending_ms = 0;
  int r;
  int ret;

#if SIZEOF_TIME_T != SIZEOF_INT
  /* wrap-around precaution */
  if(timeout_ms >= INT_MAX)
    timeout_ms = INT_MAX;
#endif

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

  /* 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. */

  if(timeout_ms > 0) {
    pending_ms = (int)timeout_ms;
    initial_tv = Curl_now();
  }

#ifdef HAVE_POLL_FINE

  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;
    pfd[num].revents = 0;
    num++;
  }

  do {
    int error;
    if(timeout_ms < 0)
      pending_ms = -1;
    else if(!timeout_ms)
      pending_ms = 0;
    r = poll(pfd, num, pending_ms);
    if(r != -1)
      break;
    error = SOCKERRNO;
    if(error && ERROR_NOT_EINTR(error))
      break;
    if(timeout_ms > 0) {
      pending_ms = (int)(timeout_ms - ELAPSED_MS());
      if(pending_ms <= 0) {
        r = 0;  /* Simulate a "call timed out" case */
        break;
      }
    }
  } while(r == -1);

  if(r < 0)
    return -1;
  if(r == 0)
    return 0;

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

  return ret;

#else  /* HAVE_POLL_FINE */

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

  FD_ZERO(&fds_read);
  if(readfd0 != CURL_SOCKET_BAD) {
    VERIFY_SOCK(readfd0);
    FD_SET(readfd0, &fds_read);
    FD_SET(readfd0, &fds_err);
    maxfd = readfd0;
  }
  if(readfd1 != CURL_SOCKET_BAD) {
    VERIFY_SOCK(readfd1);
    FD_SET(readfd1, &fds_read);
    FD_SET(readfd1, &fds_err);
    if(readfd1 > maxfd)
      maxfd = readfd1;
  }

  FD_ZERO(&fds_write);
  if(writefd != CURL_SOCKET_BAD) {
    VERIFY_SOCK(writefd);
    FD_SET(writefd, &fds_write);
    FD_SET(writefd, &fds_err);
    if(writefd > maxfd)
      maxfd = writefd;
  }

  ptimeout = (timeout_ms < 0) ? NULL : &pending_tv;

  do {
    int error;
    if(timeout_ms > 0) {
      pending_tv.tv_sec = pending_ms / 1000;
      pending_tv.tv_usec = (pending_ms % 1000) * 1000;
    }
    else if(!timeout_ms) {
      pending_tv.tv_sec = 0;
      pending_tv.tv_usec = 0;
    }

    /* 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.

       We know that we have at least one bit set in at least two fd_sets in
       this case, but we may have no bits set in either fds_read or fd_write,
       so check for that and handle it.  Luckily, with WinSock, we can _also_
       ask how many bits are set on an fd_set.

       It is unclear why WinSock doesn't just handle this for us instead of
       calling this an error.

       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).
    */
#ifdef USE_WINSOCK
    r = select((int)maxfd + 1,
               fds_read.fd_count ? &fds_read : NULL,
               fds_write.fd_count ? &fds_write : NULL,
               &fds_err, ptimeout);
#else
    r = select((int)maxfd + 1, &fds_read, &fds_write, &fds_err, ptimeout);
#endif

    if(r != -1)
      break;
    error = SOCKERRNO;
    if(error && ERROR_NOT_EINTR(error))
      break;
    if(timeout_ms > 0) {
      pending_ms = (int)(timeout_ms - ELAPSED_MS());
      if(pending_ms <= 0) {
        r = 0;  /* Simulate a "call timed out" case */
        break;
      }
    }
  } while(r == -1);

  if(r < 0)
    return -1;
  if(r == 0)
    return 0;

  ret = 0;
  if(readfd0 != CURL_SOCKET_BAD) {
    if(FD_ISSET(readfd0, &fds_read))
      ret |= CURL_CSELECT_IN;
    if(FD_ISSET(readfd0, &fds_err))
      ret |= CURL_CSELECT_ERR;
  }
  if(readfd1 != CURL_SOCKET_BAD) {
    if(FD_ISSET(readfd1, &fds_read))
      ret |= CURL_CSELECT_IN2;
    if(FD_ISSET(readfd1, &fds_err))
      ret |= CURL_CSELECT_ERR;
  }
  if(writefd != CURL_SOCKET_BAD) {
    if(FD_ISSET(writefd, &fds_write))
      ret |= CURL_CSELECT_OUT;
    if(FD_ISSET(writefd, &fds_err))
      ret |= CURL_CSELECT_ERR;
  }

  return ret;

#endif  /* HAVE_POLL_FINE */

}

/*
 * 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, int timeout_ms)
{
#ifndef HAVE_POLL_FINE
  struct timeval pending_tv;
  struct timeval *ptimeout;
  fd_set fds_read;
  fd_set fds_write;
  fd_set fds_err;
  curl_socket_t maxfd;
#endif
  struct curltime initial_tv = {0, 0};
  bool fds_none = TRUE;
  unsigned int i;
  int pending_ms = 0;
  int r;

  if(ufds) {
    for(i = 0; i < nfds; i++) {
      if(ufds[i].fd != CURL_SOCKET_BAD) {
        fds_none = FALSE;
        break;
      }
    }
  }
  if(fds_none) {
    r = Curl_wait_ms(timeout_ms);
    return r;
  }

  /* 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. */

  if(timeout_ms > 0) {
    pending_ms = timeout_ms;
    initial_tv = Curl_now();
  }

#ifdef HAVE_POLL_FINE

  do {
    int error;
    if(timeout_ms < 0)
      pending_ms = -1;
    else if(!timeout_ms)
      pending_ms = 0;
    r = poll(ufds, nfds, pending_ms);
    if(r != -1)
      break;
    error = SOCKERRNO;
    if(error && ERROR_NOT_EINTR(error))
      break;
    if(timeout_ms > 0) {
      pending_ms = (int)(timeout_ms - ELAPSED_MS());
      if(pending_ms <= 0) {
        r = 0;  /* Simulate a "call timed out" case */
        break;
      }
    }
  } while(r == -1);

  if(r < 0)
    return -1;
  if(r == 0)
    return 0;

  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);
    }
  }

#ifdef USE_WINSOCK
  /* WinSock select() can't handle zero events.  See the comment about this in
     Curl_check_socket(). */
  if(fds_read.fd_count == 0 && fds_write.fd_count == 0
     && fds_err.fd_count == 0) {
    r = Curl_wait_ms(timeout_ms);
    return r;
  }
#endif

  ptimeout = (timeout_ms < 0) ? NULL : &pending_tv;

  do {
    int error;
    if(timeout_ms > 0) {
      pending_tv.tv_sec = pending_ms / 1000;
      pending_tv.tv_usec = (pending_ms % 1000) * 1000;
    }
    else if(!timeout_ms) {
      pending_tv.tv_sec = 0;
      pending_tv.tv_usec = 0;
    }

#ifdef USE_WINSOCK
    r = select((int)maxfd + 1,
               /* WinSock select() can't handle fd_sets with zero bits set, so
                  don't give it such arguments.  See the comment about this in
                  Curl_check_socket().
               */
               fds_read.fd_count ? &fds_read : NULL,
               fds_write.fd_count ? &fds_write : NULL,
               fds_err.fd_count ? &fds_err : NULL, ptimeout);
#else
    r = select((int)maxfd + 1, &fds_read, &fds_write, &fds_err, ptimeout);
#endif
    if(r != -1)
      break;
    error = SOCKERRNO;
    if(error && ERROR_NOT_EINTR(error))
      break;
    if(timeout_ms > 0) {
      pending_ms = timeout_ms - ELAPSED_MS();
      if(pending_ms <= 0) {
        r = 0;  /* Simulate a "call timed out" case */
        break;
      }
    }
  } while(r == -1);

  if(r < 0)
    return -1;
  if(r == 0)
    return 0;

  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))
      ufds[i].revents |= POLLIN;
    if(FD_ISSET(ufds[i].fd, &fds_write))
      ufds[i].revents |= POLLOUT;
    if(FD_ISSET(ufds[i].fd, &fds_err))
      ufds[i].revents |= POLLPRI;
    if(ufds[i].revents != 0)
      r++;
  }

#endif  /* HAVE_POLL_FINE */

  return r;
}

#ifdef TPF
/*
 * This is a replacement for select() on the TPF platform.
 * It is used whenever libcurl calls select().
 * The call below to tpf_process_signals() is required because
 * TPF's select calls are not signal interruptible.
 *
 * Return values are the same as select's.
 */
int tpf_select_libcurl(int maxfds, fd_set *reads, fd_set *writes,
                       fd_set *excepts, struct timeval *tv)
{
   int rc;

   rc = tpf_select_bsd(maxfds, reads, writes, excepts, tv);
   tpf_process_signals();
   return rc;
}
#endif /* TPF */

1	/***************************************************************************
2	* _ _ ____ _
3	* Project ___\| \| \| \| _ \\| \|
4	* / __\| \| \| \| \|_) \| \|
5	* \| (__\| \|_\| \| _ <\| \|___
6	* \___\|\___/\|_\| \_\_____\|
7	*
8	* Copyright (C) 1998 - 2017, 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.haxx.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	***************************************************************************/
22
23	#include "curl_setup.h"
24
25	#ifdef HAVE_SYS_SELECT_H
26	#include <sys/select.h>
27	#endif
28
29	#if !defined(HAVE_SELECT) && !defined(HAVE_POLL_FINE)
30	#error "We can't compile without select() or poll() support."
31	#endif
32
33	#if defined(__BEOS__) && !defined(__HAIKU__)
34	/* BeOS has FD_SET defined in socket.h */
35	#include <socket.h>
36	#endif
37
38	#ifdef MSDOS
39	#include <dos.h> /* delay() */
40	#endif
41
42	#ifdef __VXWORKS__
43	#include <strings.h> /* bzero() in FD_SET */
44	#endif
45
46	#include <curl/curl.h>
47
48	#include "urldata.h"
49	#include "connect.h"
50	#include "select.h"
51	#include "warnless.h"
52
53	/* Convenience local macros */
54	#define ELAPSED_MS() (int)Curl_timediff(Curl_now(), initial_tv)
55
56	int Curl_ack_eintr = 0;
57	#define ERROR_NOT_EINTR(error) (Curl_ack_eintr \|\| error != EINTR)
58
59	/*
60	* Internal function used for waiting a specific amount of ms
61	* in Curl_socket_check() and Curl_poll() when no file descriptor
62	* is provided to wait on, just being used to delay execution.
63	* WinSock select() and poll() timeout mechanisms need a valid
64	* socket descriptor in a not null file descriptor set to work.
65	* Waiting indefinitely with this function is not allowed, a
66	* zero or negative timeout value will return immediately.
67	* Timeout resolution, accuracy, as well as maximum supported
68	* value is system dependent, neither factor is a citical issue
69	* for the intended use of this function in the library.
70	*
71	* Return values:
72	* -1 = system call error, invalid timeout value, or interrupted
73	* 0 = specified timeout has elapsed
74	*/
75	int Curl_wait_ms(int timeout_ms)	1,236✔
76	{
77	#if !defined(MSDOS) && !defined(USE_WINSOCK)
78	#ifndef HAVE_POLL_FINE
79	struct timeval pending_tv;
80	#endif
81	struct curltime initial_tv;
82	int pending_ms;
83	#endif
84	int r = 0;	1,236✔
85
86	if(!timeout_ms)	1,236✔
87	return 0;	208✔
88	if(timeout_ms < 0) {	1,028✔
89	SET_SOCKERRNO(EINVAL);	×
90	return -1;	×
91	}
92	#if defined(MSDOS)
93	delay(timeout_ms);
94	#elif defined(USE_WINSOCK)
95	Sleep(timeout_ms);
96	#else
97	pending_ms = timeout_ms;	1,028✔
98	initial_tv = Curl_now();	1,028✔
99	do {
100	int error;
101	#if defined(HAVE_POLL_FINE)
102	r = poll(NULL, 0, pending_ms);	1,028✔
103	#else
104	pending_tv.tv_sec = pending_ms / 1000;
105	pending_tv.tv_usec = (pending_ms % 1000) * 1000;
106	r = select(0, NULL, NULL, NULL, &pending_tv);
107	#endif /* HAVE_POLL_FINE */
108	if(r != -1)	1,028✔
109	break;	1,028✔
110	error = SOCKERRNO;	×
111	if(error && ERROR_NOT_EINTR(error))	×
112	break;
113	pending_ms = timeout_ms - ELAPSED_MS();	×
114	if(pending_ms <= 0) {	×
115	r = 0; /* Simulate a "call timed out" case */	×
116	break;	×
117	}
118	} while(r == -1);	×
119	#endif /* USE_WINSOCK */
120	if(r)	1,028✔
121	r = -1;	×
122	return r;	1,028✔
123	}
124
125	/*
126	* Wait for read or write events on a set of file descriptors. It uses poll()
127	* when a fine poll() is available, in order to avoid limits with FD_SETSIZE,
128	* otherwise select() is used. An error is returned if select() is being used
129	* and a file descriptor is too large for FD_SETSIZE.
130	*
131	* A negative timeout value makes this function wait indefinitely,
132	* unless no valid file descriptor is given, when this happens the
133	* negative timeout is ignored and the function times out immediately.
134	*
135	* Return values:
136	* -1 = system call error or fd >= FD_SETSIZE
137	* 0 = timeout
138	* [bitmask] = action as described below
139	*
140	* CURL_CSELECT_IN - first socket is readable
141	* CURL_CSELECT_IN2 - second socket is readable
142	* CURL_CSELECT_OUT - write socket is writable
143	* CURL_CSELECT_ERR - an error condition occurred
144	*/
145	int Curl_socket_check(curl_socket_t readfd0, /* two sockets to read from */	75,545✔
146	curl_socket_t readfd1,
147	curl_socket_t writefd, /* socket to write to */
148	time_t timeout_ms) /* milliseconds to wait */
149	{
150	#ifdef HAVE_POLL_FINE
151	struct pollfd pfd[3];
152	int num;
153	#else
154	struct timeval pending_tv;
155	struct timeval *ptimeout;
156	fd_set fds_read;
157	fd_set fds_write;
158	fd_set fds_err;
159	curl_socket_t maxfd;
160	#endif
161	struct curltime initial_tv = {0, 0};	75,545✔
162	int pending_ms = 0;	75,545✔
163	int r;
164	int ret;
165
166	#if SIZEOF_TIME_T != SIZEOF_INT
167	/* wrap-around precaution */
168	if(timeout_ms >= INT_MAX)	75,545✔
169	timeout_ms = INT_MAX;	×
170	#endif
171
172	if((readfd0 == CURL_SOCKET_BAD) && (readfd1 == CURL_SOCKET_BAD) &&	75,545✔
173	(writefd == CURL_SOCKET_BAD)) {
174	/* no sockets, just wait */
175	r = Curl_wait_ms((int)timeout_ms);	208✔
176	return r;	208✔
177	}
178
179	/* Avoid initial timestamp, avoid Curl_now() call, when elapsed
180	time in this function does not need to be measured. This happens
181	when function is called with a zero timeout or a negative timeout
182	value indicating a blocking call should be performed. */
183
184	if(timeout_ms > 0) {	75,337✔
185	pending_ms = (int)timeout_ms;	1,952✔
186	initial_tv = Curl_now();	1,952✔
187	}
188
189	#ifdef HAVE_POLL_FINE
190
191	num = 0;	75,337✔
192	if(readfd0 != CURL_SOCKET_BAD) {	75,337✔
193	pfd[num].fd = readfd0;	62,469✔
194	pfd[num].events = POLLRDNORM\|POLLIN\|POLLRDBAND\|POLLPRI;	62,469✔
195	pfd[num].revents = 0;	62,469✔
196	num++;	62,469✔
197	}
198	if(readfd1 != CURL_SOCKET_BAD) {	75,337✔
199	pfd[num].fd = readfd1;	44✔
200	pfd[num].events = POLLRDNORM\|POLLIN\|POLLRDBAND\|POLLPRI;	44✔
201	pfd[num].revents = 0;	44✔
202	num++;	44✔
203	}
204	if(writefd != CURL_SOCKET_BAD) {	75,337✔
205	pfd[num].fd = writefd;	14,569✔
206	pfd[num].events = POLLWRNORM\|POLLOUT;	14,569✔
207	pfd[num].revents = 0;	14,569✔
208	num++;	14,569✔
209	}
210
211	do {
212	int error;
213	if(timeout_ms < 0)	75,337✔
214	pending_ms = -1;	×
215	else if(!timeout_ms)	75,337✔
216	pending_ms = 0;	73,385✔
217	r = poll(pfd, num, pending_ms);	75,337✔
218	if(r != -1)	75,337✔
219	break;	75,337✔
220	error = SOCKERRNO;	×
221	if(error && ERROR_NOT_EINTR(error))	×
222	break;
223	if(timeout_ms > 0) {	×
224	pending_ms = (int)(timeout_ms - ELAPSED_MS());	×
225	if(pending_ms <= 0) {	×
226	r = 0; /* Simulate a "call timed out" case */	×
227	break;	×
228	}
229	}
230	} while(r == -1);	×
231
232	if(r < 0)	75,337✔
233	return -1;	×
234	if(r == 0)	75,337✔
235	return 0;	16,829✔
236
237	ret = 0;	58,508✔
238	num = 0;	58,508✔
239	if(readfd0 != CURL_SOCKET_BAD) {	58,508✔
240	if(pfd[num].revents & (POLLRDNORM\|POLLIN\|POLLERR\|POLLHUP))	46,821✔
241	ret \|= CURL_CSELECT_IN;	45,098✔
242	if(pfd[num].revents & (POLLRDBAND\|POLLPRI\|POLLNVAL))	46,821✔
243	ret \|= CURL_CSELECT_ERR;	×
244	num++;	46,821✔
245	}
246	if(readfd1 != CURL_SOCKET_BAD) {	58,508✔
247	if(pfd[num].revents & (POLLRDNORM\|POLLIN\|POLLERR\|POLLHUP))	28✔
248	ret \|= CURL_CSELECT_IN2;	22✔
249	if(pfd[num].revents & (POLLRDBAND\|POLLPRI\|POLLNVAL))	28✔
250	ret \|= CURL_CSELECT_ERR;	×
251	num++;	28✔
252	}
253	if(writefd != CURL_SOCKET_BAD) {	58,508✔
254	if(pfd[num].revents & (POLLWRNORM\|POLLOUT))	13,388✔
255	ret \|= CURL_CSELECT_OUT;	13,388✔
256	if(pfd[num].revents & (POLLERR\|POLLHUP\|POLLNVAL))	13,388✔
257	ret \|= CURL_CSELECT_ERR;	13✔
258	}
259
260	return ret;	58,508✔
261
262	#else /* HAVE_POLL_FINE */
263
264	FD_ZERO(&fds_err);
265	maxfd = (curl_socket_t)-1;
266
267	FD_ZERO(&fds_read);
268	if(readfd0 != CURL_SOCKET_BAD) {
269	VERIFY_SOCK(readfd0);
270	FD_SET(readfd0, &fds_read);
271	FD_SET(readfd0, &fds_err);
272	maxfd = readfd0;
273	}
274	if(readfd1 != CURL_SOCKET_BAD) {
275	VERIFY_SOCK(readfd1);
276	FD_SET(readfd1, &fds_read);
277	FD_SET(readfd1, &fds_err);
278	if(readfd1 > maxfd)
279	maxfd = readfd1;
280	}
281
282	FD_ZERO(&fds_write);
283	if(writefd != CURL_SOCKET_BAD) {
284	VERIFY_SOCK(writefd);
285	FD_SET(writefd, &fds_write);
286	FD_SET(writefd, &fds_err);
287	if(writefd > maxfd)
288	maxfd = writefd;
289	}
290
291	ptimeout = (timeout_ms < 0) ? NULL : &pending_tv;
292
293	do {
294	int error;
295	if(timeout_ms > 0) {
296	pending_tv.tv_sec = pending_ms / 1000;
297	pending_tv.tv_usec = (pending_ms % 1000) * 1000;
298	}
299	else if(!timeout_ms) {
300	pending_tv.tv_sec = 0;
301	pending_tv.tv_usec = 0;
302	}
303
304	/* WinSock select() must not be called with an fd_set that contains zero
305	fd flags, or it will return WSAEINVAL. But, it also can't be called
306	with no fd_sets at all! From the documentation:
307
308	Any two of the parameters, readfds, writefds, or exceptfds, can be
309	given as null. At least one must be non-null, and any non-null
310	descriptor set must contain at least one handle to a socket.
311
312	We know that we have at least one bit set in at least two fd_sets in
313	this case, but we may have no bits set in either fds_read or fd_write,
314	so check for that and handle it. Luckily, with WinSock, we can _also_
315	ask how many bits are set on an fd_set.
316
317	It is unclear why WinSock doesn't just handle this for us instead of
318	calling this an error.
319
320	Note also that WinSock ignores the first argument, so we don't worry
321	about the fact that maxfd is computed incorrectly with WinSock (since
322	curl_socket_t is unsigned in such cases and thus -1 is the largest
323	value).
324	*/
325	#ifdef USE_WINSOCK
326	r = select((int)maxfd + 1,
327	fds_read.fd_count ? &fds_read : NULL,
328	fds_write.fd_count ? &fds_write : NULL,
329	&fds_err, ptimeout);
330	#else
331	r = select((int)maxfd + 1, &fds_read, &fds_write, &fds_err, ptimeout);
332	#endif
333
334	if(r != -1)
335	break;
336	error = SOCKERRNO;
337	if(error && ERROR_NOT_EINTR(error))
338	break;
339	if(timeout_ms > 0) {
340	pending_ms = (int)(timeout_ms - ELAPSED_MS());
341	if(pending_ms <= 0) {
342	r = 0; /* Simulate a "call timed out" case */
343	break;
344	}
345	}
346	} while(r == -1);
347
348	if(r < 0)
349	return -1;
350	if(r == 0)
351	return 0;
352
353	ret = 0;
354	if(readfd0 != CURL_SOCKET_BAD) {
355	if(FD_ISSET(readfd0, &fds_read))
356	ret \|= CURL_CSELECT_IN;
357	if(FD_ISSET(readfd0, &fds_err))
358	ret \|= CURL_CSELECT_ERR;
359	}
360	if(readfd1 != CURL_SOCKET_BAD) {
361	if(FD_ISSET(readfd1, &fds_read))
362	ret \|= CURL_CSELECT_IN2;
363	if(FD_ISSET(readfd1, &fds_err))
364	ret \|= CURL_CSELECT_ERR;
365	}
366	if(writefd != CURL_SOCKET_BAD) {
367	if(FD_ISSET(writefd, &fds_write))
368	ret \|= CURL_CSELECT_OUT;
369	if(FD_ISSET(writefd, &fds_err))
370	ret \|= CURL_CSELECT_ERR;
371	}
372
373	return ret;
374
375	#endif /* HAVE_POLL_FINE */
376
377	}
378
379	/*
380	* This is a wrapper around poll(). If poll() does not exist, then
381	* select() is used instead. An error is returned if select() is
382	* being used and a file descriptor is too large for FD_SETSIZE.
383	* A negative timeout value makes this function wait indefinitely,
384	* unless no valid file descriptor is given, when this happens the
385	* negative timeout is ignored and the function times out immediately.
386	*
387	* Return values:
388	* -1 = system call error or fd >= FD_SETSIZE
389	* 0 = timeout
390	* N = number of structures with non zero revent fields
391	*/
392	int Curl_poll(struct pollfd ufds[], unsigned int nfds, int timeout_ms)	80,365,741✔
393	{
394	#ifndef HAVE_POLL_FINE
395	struct timeval pending_tv;
396	struct timeval *ptimeout;
397	fd_set fds_read;
398	fd_set fds_write;
399	fd_set fds_err;
400	curl_socket_t maxfd;
401	#endif
402	struct curltime initial_tv = {0, 0};	80,365,741✔
403	bool fds_none = TRUE;	80,365,741✔
404	unsigned int i;
405	int pending_ms = 0;	80,365,741✔
406	int r;
407
408	if(ufds) {	80,365,741✔
409	for(i = 0; i < nfds; i++) {	80,365,741✔
410	if(ufds[i].fd != CURL_SOCKET_BAD) {	80,364,735✔
411	fds_none = FALSE;	80,364,735✔
412	break;	80,364,735✔
413	}
414	}
415	}
416	if(fds_none) {	80,365,741✔
417	r = Curl_wait_ms(timeout_ms);	1,006✔
418	return r;	1,006✔
419	}
420
421	/* Avoid initial timestamp, avoid Curl_now() call, when elapsed
422	time in this function does not need to be measured. This happens
423	when function is called with a zero timeout or a negative timeout
424	value indicating a blocking call should be performed. */
425
426	if(timeout_ms > 0) {	80,364,735✔
427	pending_ms = timeout_ms;	2,162,550✔
428	initial_tv = Curl_now();	2,162,550✔
429	}
430
431	#ifdef HAVE_POLL_FINE
432
433	do {
434	int error;
435	if(timeout_ms < 0)	80,364,735✔
436	pending_ms = -1;	4✔
437	else if(!timeout_ms)	80,364,731✔
438	pending_ms = 0;	78,202,181✔
439	r = poll(ufds, nfds, pending_ms);	80,364,735✔
440	if(r != -1)	80,364,735✔
441	break;	80,364,735✔
442	error = SOCKERRNO;	×
443	if(error && ERROR_NOT_EINTR(error))	×
444	break;
445	if(timeout_ms > 0) {	×
446	pending_ms = (int)(timeout_ms - ELAPSED_MS());	×
447	if(pending_ms <= 0) {	×
448	r = 0; /* Simulate a "call timed out" case */	×
449	break;	×
450	}
451	}
452	} while(r == -1);	×
453
454	if(r < 0)	80,364,735✔
455	return -1;	×
456	if(r == 0)	80,364,735✔
457	return 0;	78,201,089✔
458
459	for(i = 0; i < nfds; i++) {	6,442,852✔
460	if(ufds[i].fd == CURL_SOCKET_BAD)	4,279,206✔
461	continue;	×
462	if(ufds[i].revents & POLLHUP)	4,279,206✔
463	ufds[i].revents \|= POLLIN;	31✔
464	if(ufds[i].revents & POLLERR)	4,279,206✔
465	ufds[i].revents \|= (POLLIN\|POLLOUT);	32✔
466	}
467
468	#else /* HAVE_POLL_FINE */
469
470	FD_ZERO(&fds_read);
471	FD_ZERO(&fds_write);
472	FD_ZERO(&fds_err);
473	maxfd = (curl_socket_t)-1;
474
475	for(i = 0; i < nfds; i++) {
476	ufds[i].revents = 0;
477	if(ufds[i].fd == CURL_SOCKET_BAD)
478	continue;
479	VERIFY_SOCK(ufds[i].fd);
480	if(ufds[i].events & (POLLIN\|POLLOUT\|POLLPRI\|
481	POLLRDNORM\|POLLWRNORM\|POLLRDBAND)) {
482	if(ufds[i].fd > maxfd)
483	maxfd = ufds[i].fd;
484	if(ufds[i].events & (POLLRDNORM\|POLLIN))
485	FD_SET(ufds[i].fd, &fds_read);
486	if(ufds[i].events & (POLLWRNORM\|POLLOUT))
487	FD_SET(ufds[i].fd, &fds_write);
488	if(ufds[i].events & (POLLRDBAND\|POLLPRI))
489	FD_SET(ufds[i].fd, &fds_err);
490	}
491	}
492
493	#ifdef USE_WINSOCK
494	/* WinSock select() can't handle zero events. See the comment about this in
495	Curl_check_socket(). */
496	if(fds_read.fd_count == 0 && fds_write.fd_count == 0
497	&& fds_err.fd_count == 0) {
498	r = Curl_wait_ms(timeout_ms);
499	return r;
500	}
501	#endif
502
503	ptimeout = (timeout_ms < 0) ? NULL : &pending_tv;
504
505	do {
506	int error;
507	if(timeout_ms > 0) {
508	pending_tv.tv_sec = pending_ms / 1000;
509	pending_tv.tv_usec = (pending_ms % 1000) * 1000;
510	}
511	else if(!timeout_ms) {
512	pending_tv.tv_sec = 0;
513	pending_tv.tv_usec = 0;
514	}
515
516	#ifdef USE_WINSOCK
517	r = select((int)maxfd + 1,
518	/* WinSock select() can't handle fd_sets with zero bits set, so
519	don't give it such arguments. See the comment about this in
520	Curl_check_socket().
521	*/
522	fds_read.fd_count ? &fds_read : NULL,
523	fds_write.fd_count ? &fds_write : NULL,
524	fds_err.fd_count ? &fds_err : NULL, ptimeout);
525	#else
526	r = select((int)maxfd + 1, &fds_read, &fds_write, &fds_err, ptimeout);
527	#endif
528	if(r != -1)
529	break;
530	error = SOCKERRNO;
531	if(error && ERROR_NOT_EINTR(error))
532	break;
533	if(timeout_ms > 0) {
534	pending_ms = timeout_ms - ELAPSED_MS();
535	if(pending_ms <= 0) {
536	r = 0; /* Simulate a "call timed out" case */
537	break;
538	}
539	}
540	} while(r == -1);
541
542	if(r < 0)
543	return -1;
544	if(r == 0)
545	return 0;
546
547	r = 0;
548	for(i = 0; i < nfds; i++) {
549	ufds[i].revents = 0;
550	if(ufds[i].fd == CURL_SOCKET_BAD)
551	continue;
552	if(FD_ISSET(ufds[i].fd, &fds_read))
553	ufds[i].revents \|= POLLIN;
554	if(FD_ISSET(ufds[i].fd, &fds_write))
555	ufds[i].revents \|= POLLOUT;
556	if(FD_ISSET(ufds[i].fd, &fds_err))
557	ufds[i].revents \|= POLLPRI;
558	if(ufds[i].revents != 0)
559	r++;
560	}
561
562	#endif /* HAVE_POLL_FINE */
563
564	return r;	2,163,646✔
565	}
566
567	#ifdef TPF
568	/*
569	* This is a replacement for select() on the TPF platform.
570	* It is used whenever libcurl calls select().
571	* The call below to tpf_process_signals() is required because
572	* TPF's select calls are not signal interruptible.
573	*
574	* Return values are the same as select's.
575	*/
576	int tpf_select_libcurl(int maxfds, fd_set reads, fd_set writes,
577	fd_set excepts, struct timeval tv)
578	{
579	int rc;
580
581	rc = tpf_select_bsd(maxfds, reads, writes, excepts, tv);
582	tpf_process_signals();
583	return rc;
584	}
585	#endif /* TPF */

curl / curl / 10242

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous