Restoring authorship annotation for <thegeorg@yandex-team.ru>. Commit 1 of 2.

1 files changed, 197 insertions, 197 deletions

diff --git a/contrib/libs/curl/lib/select.c b/contrib/libs/curl/lib/select.c
index 7d1f944cdb..67276b1052 100644
--- a/contrib/libs/curl/lib/select.c
+++ b/contrib/libs/curl/lib/select.c
@@ -5,11 +5,11 @@
  *                            | (__| |_| |  _ <| |___
  *                             \___|\___/|_| \_\_____|
  *
- * Copyright (C) 1998 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * 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
- * are also available at https://curl.se/docs/copyright.html.
+ * 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
@@ -22,12 +22,12 @@
 
 #include "curl_setup.h"
 
-#include <limits.h>
-
+#include <limits.h> 
+ 
 #ifdef HAVE_SYS_SELECT_H
 #include <sys/select.h>
-#elif defined(HAVE_UNISTD_H)
-#include <unistd.h>
+#elif defined(HAVE_UNISTD_H) 
+#include <unistd.h> 
 #endif
 
 #if !defined(HAVE_SELECT) && !defined(HAVE_POLL_FINE)
@@ -52,7 +52,7 @@
 #include "urldata.h"
 #include "connect.h"
 #include "select.h"
-#include "timeval.h"
+#include "timeval.h" 
 #include "warnless.h"
 
 /*
@@ -71,7 +71,7 @@
  *   -1 = system call error, invalid timeout value, or interrupted
  *    0 = specified timeout has elapsed
  */
-int Curl_wait_ms(timediff_t timeout_ms)
+int Curl_wait_ms(timediff_t timeout_ms) 
 {
   int r = 0;
 
@@ -83,46 +83,46 @@ int Curl_wait_ms(timediff_t timeout_ms)
   }
 #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);
+#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);
+  /* 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;
-    timediff_t tv_sec = timeout_ms / 1000;
-    timediff_t tv_usec = (timeout_ms % 1000) * 1000; /* max=999999 */
-#ifdef HAVE_SUSECONDS_T
-#if TIMEDIFF_T_MAX > TIME_T_MAX
-    /* tv_sec overflow check in case time_t is signed */
-    if(tv_sec > TIME_T_MAX)
-      tv_sec = TIME_T_MAX;
-#endif
-    pending_tv.tv_sec = (time_t)tv_sec;
-    pending_tv.tv_usec = (suseconds_t)tv_usec;
-#else
-#if TIMEDIFF_T_MAX > INT_MAX
-    /* tv_sec overflow check in case time_t is signed */
-    if(tv_sec > INT_MAX)
-      tv_sec = INT_MAX;
-#endif
-    pending_tv.tv_sec = (int)tv_sec;
-    pending_tv.tv_usec = (int)tv_usec;
-#endif
+  { 
+    struct timeval pending_tv; 
+    timediff_t tv_sec = timeout_ms / 1000; 
+    timediff_t tv_usec = (timeout_ms % 1000) * 1000; /* max=999999 */ 
+#ifdef HAVE_SUSECONDS_T 
+#if TIMEDIFF_T_MAX > TIME_T_MAX 
+    /* tv_sec overflow check in case time_t is signed */ 
+    if(tv_sec > TIME_T_MAX) 
+      tv_sec = TIME_T_MAX; 
+#endif 
+    pending_tv.tv_sec = (time_t)tv_sec; 
+    pending_tv.tv_usec = (suseconds_t)tv_usec; 
+#else 
+#if TIMEDIFF_T_MAX > INT_MAX 
+    /* tv_sec overflow check in case time_t is signed */ 
+    if(tv_sec > INT_MAX) 
+      tv_sec = INT_MAX; 
+#endif 
+    pending_tv.tv_sec = (int)tv_sec; 
+    pending_tv.tv_usec = (int)tv_usec; 
+#endif 
     r = select(0, NULL, NULL, NULL, &pending_tv);
-  }
+  } 
 #endif /* HAVE_POLL_FINE */
 #endif /* USE_WINSOCK */
   if(r)
@@ -131,96 +131,96 @@ int Curl_wait_ms(timediff_t timeout_ms)
 }
 
 /*
- * 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
- */
-int Curl_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 = &pending_tv;
-  if(timeout_ms < 0) {
-    ptimeout = NULL;
-  }
-  else if(timeout_ms > 0) {
-    timediff_t tv_sec = timeout_ms / 1000;
-    timediff_t tv_usec = (timeout_ms % 1000) * 1000; /* max=999999 */
-#ifdef HAVE_SUSECONDS_T
-#if TIMEDIFF_T_MAX > TIME_T_MAX
-    /* tv_sec overflow check in case time_t is signed */
-    if(tv_sec > TIME_T_MAX)
-      tv_sec = TIME_T_MAX;
-#endif
-    pending_tv.tv_sec = (time_t)tv_sec;
-    pending_tv.tv_usec = (suseconds_t)tv_usec;
-#elif defined(WIN32) /* maybe also others in the future */
-#if TIMEDIFF_T_MAX > LONG_MAX
-    /* tv_sec overflow check on Windows there we know it is long */
-    if(tv_sec > LONG_MAX)
-      tv_sec = LONG_MAX;
-#endif
-    pending_tv.tv_sec = (long)tv_sec;
-    pending_tv.tv_usec = (long)tv_usec;
-#else
-#if TIMEDIFF_T_MAX > INT_MAX
-    /* tv_sec overflow check in case time_t is signed */
-    if(tv_sec > INT_MAX)
-      tv_sec = INT_MAX;
-#endif
-    pending_tv.tv_sec = (int)tv_sec;
-    pending_tv.tv_usec = (int)tv_usec;
-#endif
-  }
-  else {
-    pending_tv.tv_sec = 0;
-    pending_tv.tv_usec = 0;
-  }
-
-#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
-}
-
-/*
+ * 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 
+ */ 
+int Curl_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 = &pending_tv; 
+  if(timeout_ms < 0) { 
+    ptimeout = NULL; 
+  } 
+  else if(timeout_ms > 0) { 
+    timediff_t tv_sec = timeout_ms / 1000; 
+    timediff_t tv_usec = (timeout_ms % 1000) * 1000; /* max=999999 */ 
+#ifdef HAVE_SUSECONDS_T 
+#if TIMEDIFF_T_MAX > TIME_T_MAX 
+    /* tv_sec overflow check in case time_t is signed */ 
+    if(tv_sec > TIME_T_MAX) 
+      tv_sec = TIME_T_MAX; 
+#endif 
+    pending_tv.tv_sec = (time_t)tv_sec; 
+    pending_tv.tv_usec = (suseconds_t)tv_usec; 
+#elif defined(WIN32) /* maybe also others in the future */ 
+#if TIMEDIFF_T_MAX > LONG_MAX 
+    /* tv_sec overflow check on Windows there we know it is long */ 
+    if(tv_sec > LONG_MAX) 
+      tv_sec = LONG_MAX; 
+#endif 
+    pending_tv.tv_sec = (long)tv_sec; 
+    pending_tv.tv_usec = (long)tv_usec; 
+#else 
+#if TIMEDIFF_T_MAX > INT_MAX 
+    /* tv_sec overflow check in case time_t is signed */ 
+    if(tv_sec > INT_MAX) 
+      tv_sec = INT_MAX; 
+#endif 
+    pending_tv.tv_sec = (int)tv_sec; 
+    pending_tv.tv_usec = (int)tv_usec; 
+#endif 
+  } 
+  else { 
+    pending_tv.tv_sec = 0; 
+    pending_tv.tv_usec = 0; 
+  } 
+ 
+#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 
+} 
+ 
+/* 
  * 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
@@ -243,7 +243,7 @@ int Curl_select(curl_socket_t maxfd,   /* highest socket number */
 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 */
+                      timediff_t timeout_ms) /* milliseconds to wait */ 
 {
   struct pollfd pfd[3];
   int num;
@@ -252,7 +252,7 @@ int Curl_socket_check(curl_socket_t readfd0, /* two sockets to read from */
   if((readfd0 == CURL_SOCKET_BAD) && (readfd1 == CURL_SOCKET_BAD) &&
      (writefd == CURL_SOCKET_BAD)) {
     /* no sockets, just wait */
-    return Curl_wait_ms(timeout_ms);
+    return Curl_wait_ms(timeout_ms); 
   }
 
   /* Avoid initial timestamp, avoid Curl_now() call, when elapsed
@@ -275,39 +275,39 @@ int Curl_socket_check(curl_socket_t readfd0, /* two sockets to read from */
   }
   if(writefd != CURL_SOCKET_BAD) {
     pfd[num].fd = writefd;
-    pfd[num].events = POLLWRNORM|POLLOUT|POLLPRI;
+    pfd[num].events = POLLWRNORM|POLLOUT|POLLPRI; 
     pfd[num].revents = 0;
     num++;
   }
 
-  r = Curl_poll(pfd, num, timeout_ms);
-  if(r <= 0)
-    return r;
+  r = Curl_poll(pfd, num, timeout_ms); 
+  if(r <= 0) 
+    return r; 
 
-  r = 0;
+  r = 0; 
   num = 0;
   if(readfd0 != CURL_SOCKET_BAD) {
     if(pfd[num].revents & (POLLRDNORM|POLLIN|POLLERR|POLLHUP))
-      r |= CURL_CSELECT_IN;
+      r |= CURL_CSELECT_IN; 
     if(pfd[num].revents & (POLLRDBAND|POLLPRI|POLLNVAL))
-      r |= CURL_CSELECT_ERR;
+      r |= CURL_CSELECT_ERR; 
     num++;
   }
   if(readfd1 != CURL_SOCKET_BAD) {
     if(pfd[num].revents & (POLLRDNORM|POLLIN|POLLERR|POLLHUP))
-      r |= CURL_CSELECT_IN2;
+      r |= CURL_CSELECT_IN2; 
     if(pfd[num].revents & (POLLRDBAND|POLLPRI|POLLNVAL))
-      r |= CURL_CSELECT_ERR;
+      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;
+      r |= CURL_CSELECT_OUT; 
+    if(pfd[num].revents & (POLLERR|POLLHUP|POLLPRI|POLLNVAL)) 
+      r |= CURL_CSELECT_ERR; 
   }
 
-  return r;
+  return r; 
 }
 
 /*
@@ -323,11 +323,11 @@ int Curl_socket_check(curl_socket_t readfd0, /* two sockets to read from */
  *    0 = timeout
  *    N = number of structures with non zero revent fields
  */
-int Curl_poll(struct pollfd ufds[], unsigned int nfds, timediff_t timeout_ms)
+int Curl_poll(struct pollfd ufds[], unsigned int nfds, timediff_t timeout_ms) 
 {
-#ifdef HAVE_POLL_FINE
-  int pending_ms;
-#else
+#ifdef HAVE_POLL_FINE 
+  int pending_ms; 
+#else 
   fd_set fds_read;
   fd_set fds_write;
   fd_set fds_err;
@@ -346,8 +346,8 @@ int Curl_poll(struct pollfd ufds[], unsigned int nfds, timediff_t timeout_ms)
     }
   }
   if(fds_none) {
-    /* no sockets, just wait */
-    return Curl_wait_ms(timeout_ms);
+    /* no sockets, just wait */ 
+    return Curl_wait_ms(timeout_ms); 
   }
 
   /* Avoid initial timestamp, avoid Curl_now() call, when elapsed
@@ -357,20 +357,20 @@ int Curl_poll(struct pollfd ufds[], unsigned int nfds, timediff_t timeout_ms)
 
 #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)
-    return r;
+  /* 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) 
+    return r; 
 
   for(i = 0; i < nfds; i++) {
     if(ufds[i].fd == CURL_SOCKET_BAD)
@@ -378,7 +378,7 @@ int Curl_poll(struct pollfd ufds[], unsigned int nfds, timediff_t timeout_ms)
     if(ufds[i].revents & POLLHUP)
       ufds[i].revents |= POLLIN;
     if(ufds[i].revents & POLLERR)
-      ufds[i].revents |= POLLIN|POLLOUT;
+      ufds[i].revents |= POLLIN|POLLOUT; 
   }
 
 #else  /* HAVE_POLL_FINE */
@@ -394,7 +394,7 @@ int Curl_poll(struct pollfd ufds[], unsigned int nfds, timediff_t timeout_ms)
       continue;
     VERIFY_SOCK(ufds[i].fd);
     if(ufds[i].events & (POLLIN|POLLOUT|POLLPRI|
-                         POLLRDNORM|POLLWRNORM|POLLRDBAND)) {
+                         POLLRDNORM|POLLWRNORM|POLLRDBAND)) { 
       if(ufds[i].fd > maxfd)
         maxfd = ufds[i].fd;
       if(ufds[i].events & (POLLRDNORM|POLLIN))
@@ -406,14 +406,14 @@ int Curl_poll(struct pollfd ufds[], unsigned int nfds, timediff_t timeout_ms)
     }
   }
 
-  /*
-     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 = Curl_select(maxfd, &fds_read, &fds_write, &fds_err, timeout_ms);
-  if(r <= 0)
+  /* 
+     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 = Curl_select(maxfd, &fds_read, &fds_write, &fds_err, timeout_ms); 
+  if(r <= 0) 
     return r;
 
   r = 0;
@@ -421,24 +421,24 @@ int Curl_poll(struct pollfd ufds[], unsigned int nfds, timediff_t timeout_ms)
     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(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 != 0)
       r++;
   }