Restoring authorship annotation for Nikita Slyusarev <nslus@yandex-team.com>. Commit 1 of 2.

1 files changed, 258 insertions, 258 deletions

diff --git a/contrib/libs/curl/lib/select.c b/contrib/libs/curl/lib/select.c
index 7d1f944cdb..9160c760e4 100644
--- a/contrib/libs/curl/lib/select.c
+++ b/contrib/libs/curl/lib/select.c
@@ -1,88 +1,88 @@
-/***************************************************************************
- *                                  _   _ ____  _
- *  Project                     ___| | | |  _ \| |
- *                             / __| | | | |_) | |
- *                            | (__| |_| |  _ <| |___
- *                             \___|\___/|_| \_\_____|
- *
+/*************************************************************************** 
+ *                                  _   _ ____  _ 
+ *  Project                     ___| | | |  _ \| | 
+ *                             / __| | | | |_) | | 
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____| 
+ * 
  * Copyright (C) 1998 - 2020, 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
+ * 
+ * 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.
- *
- ***************************************************************************/
-
-#include "curl_setup.h"
-
+ * 
+ * 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" 
+ 
 #include <limits.h>
 
-#ifdef HAVE_SYS_SELECT_H
-#include <sys/select.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
-
-#if defined(__BEOS__) && !defined(__HAIKU__)
-/* BeOS has FD_SET defined in socket.h */
-#include <socket.h>
-#endif
-
-#ifdef MSDOS
-#include <dos.h>  /* delay() */
-#endif
-
+#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 <curl/curl.h> 
+ 
+#include "urldata.h" 
+#include "connect.h" 
+#include "select.h" 
 #include "timeval.h"
-#include "warnless.h"
-
-/*
- * Internal function used for waiting a specific amount of ms
+#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 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
- */
+ * 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(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);
+{ 
+  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
@@ -91,15 +91,15 @@ int Curl_wait_ms(timediff_t timeout_ms)
     /* don't use ULONG_MAX, because that is equal to INFINITE */
 #endif
   Sleep((ULONG)timeout_ms);
-#else
-#if defined(HAVE_POLL_FINE)
+#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
+#else 
   {
     struct timeval pending_tv;
     timediff_t tv_sec = timeout_ms / 1000;
@@ -121,16 +121,16 @@ int Curl_wait_ms(timediff_t timeout_ms)
     pending_tv.tv_sec = (int)tv_sec;
     pending_tv.tv_usec = (int)tv_usec;
 #endif
-    r = select(0, NULL, NULL, NULL, &pending_tv);
+    r = select(0, NULL, NULL, NULL, &pending_tv); 
   }
-#endif /* HAVE_POLL_FINE */
-#endif /* USE_WINSOCK */
-  if(r)
-    r = -1;
-  return r;
-}
-
-/*
+#endif /* HAVE_POLL_FINE */ 
+#endif /* USE_WINSOCK */ 
+  if(r) 
+    r = -1; 
+  return r; 
+} 
+ 
+/* 
  * 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
@@ -221,142 +221,142 @@ int Curl_select(curl_socket_t maxfd,   /* highest socket number */
 }
 
 /*
- * 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,
+ * 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 */
+ * 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 */
+{ 
+  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;
+     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++;
-  }
-
+    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))
+  num = 0; 
+  if(readfd0 != CURL_SOCKET_BAD) { 
+    if(pfd[num].revents & (POLLRDNORM|POLLIN|POLLERR|POLLHUP)) 
       r |= CURL_CSELECT_IN;
-    if(pfd[num].revents & (POLLRDBAND|POLLPRI|POLLNVAL))
+    if(pfd[num].revents & (POLLRDBAND|POLLPRI|POLLNVAL)) 
       r |= CURL_CSELECT_ERR;
-    num++;
-  }
-  if(readfd1 != CURL_SOCKET_BAD) {
-    if(pfd[num].revents & (POLLRDNORM|POLLIN|POLLERR|POLLHUP))
+    num++; 
+  } 
+  if(readfd1 != CURL_SOCKET_BAD) { 
+    if(pfd[num].revents & (POLLRDNORM|POLLIN|POLLERR|POLLHUP)) 
       r |= CURL_CSELECT_IN2;
-    if(pfd[num].revents & (POLLRDBAND|POLLPRI|POLLNVAL))
+    if(pfd[num].revents & (POLLRDBAND|POLLPRI|POLLNVAL)) 
       r |= CURL_CSELECT_ERR;
-    num++;
-  }
-  if(writefd != CURL_SOCKET_BAD) {
-    if(pfd[num].revents & (POLLWRNORM|POLLOUT))
+    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,
+} 
+ 
+/* 
+ * 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
- */
+ * 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) {
+  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
-
+     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)
@@ -371,41 +371,41 @@ int Curl_poll(struct pollfd ufds[], unsigned int nfds, timediff_t timeout_ms)
   r = poll(ufds, nfds, pending_ms);
   if(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)
+ 
+  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|
+  } 
+ 
+#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);
-    }
-  }
-
+      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
@@ -416,11 +416,11 @@ int Curl_poll(struct pollfd ufds[], unsigned int nfds, timediff_t timeout_ms)
   if(r <= 0)
     return r;
 
-  r = 0;
-  for(i = 0; i < nfds; i++) {
-    ufds[i].revents = 0;
-    if(ufds[i].fd == CURL_SOCKET_BAD)
-      continue;
+  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;
@@ -439,31 +439,31 @@ int Curl_poll(struct pollfd ufds[], unsigned int nfds, timediff_t timeout_ms)
       if(ufds[i].events & POLLPRI)
         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.
- */
+    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();
+{ 
+   int rc; 
+ 
+   rc = tpf_select_bsd(maxfds, reads, writes, excepts, tv); 
+   tpf_process_signals(); 
    return rc;
-}
-#endif /* TPF */
+} 
+#endif /* TPF */