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

1 files changed, 116 insertions, 116 deletions

diff --git a/contrib/libs/curl/lib/hostip.c b/contrib/libs/curl/lib/hostip.c
index aa7c1cf7fd..c6435f1f97 100644
--- a/contrib/libs/curl/lib/hostip.c
+++ b/contrib/libs/curl/lib/hostip.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
@@ -59,7 +59,7 @@
 #include "strerror.h"
 #include "url.h"
 #include "inet_ntop.h"
-#include "inet_pton.h" 
+#include "inet_pton.h"
 #include "multiif.h"
 #include "doh.h"
 #include "warnless.h"
@@ -120,7 +120,7 @@ static void freednsentry(void *freethis);
 /*
  * Return # of addresses in a Curl_addrinfo struct
  */
-int Curl_num_addresses(const struct Curl_addrinfo *addr) 
+int Curl_num_addresses(const struct Curl_addrinfo *addr)
 {
   int i = 0;
   while(addr) {
@@ -131,35 +131,35 @@ int Curl_num_addresses(const struct Curl_addrinfo *addr)
 }
 
 /*
- * Curl_printable_address() stores a printable version of the 1st address 
+ * Curl_printable_address() stores a printable version of the 1st address
  * given in the 'ai' argument. The result will be stored in the buf that is
  * bufsize bytes big.
  *
- * If the conversion fails, the target buffer is empty. 
+ * If the conversion fails, the target buffer is empty.
  */
-void Curl_printable_address(const struct Curl_addrinfo *ai, char *buf, 
-                            size_t bufsize) 
+void Curl_printable_address(const struct Curl_addrinfo *ai, char *buf,
+                            size_t bufsize)
 {
-  DEBUGASSERT(bufsize); 
-  buf[0] = 0; 
+  DEBUGASSERT(bufsize);
+  buf[0] = 0;
 
   switch(ai->ai_family) {
-  case AF_INET: { 
-    const struct sockaddr_in *sa4 = (const void *)ai->ai_addr; 
-    const struct in_addr *ipaddr4 = &sa4->sin_addr; 
-    (void)Curl_inet_ntop(ai->ai_family, (const void *)ipaddr4, buf, bufsize); 
-    break; 
-  } 
+  case AF_INET: {
+    const struct sockaddr_in *sa4 = (const void *)ai->ai_addr;
+    const struct in_addr *ipaddr4 = &sa4->sin_addr;
+    (void)Curl_inet_ntop(ai->ai_family, (const void *)ipaddr4, buf, bufsize);
+    break;
+  }
 #ifdef ENABLE_IPV6
-  case AF_INET6: { 
-    const struct sockaddr_in6 *sa6 = (const void *)ai->ai_addr; 
-    const struct in6_addr *ipaddr6 = &sa6->sin6_addr; 
-    (void)Curl_inet_ntop(ai->ai_family, (const void *)ipaddr6, buf, bufsize); 
-    break; 
-  } 
+  case AF_INET6: {
+    const struct sockaddr_in6 *sa6 = (const void *)ai->ai_addr;
+    const struct in6_addr *ipaddr6 = &sa6->sin6_addr;
+    (void)Curl_inet_ntop(ai->ai_family, (const void *)ipaddr6, buf, bufsize);
+    break;
+  }
 #endif
-  default: 
-    break; 
+  default:
+    break;
   }
 }
 
@@ -206,7 +206,7 @@ hostcache_timestamp_remove(void *datap, void *hc)
  * Prune the DNS cache. This assumes that a lock has already been taken.
  */
 static void
-hostcache_prune(struct Curl_hash *hostcache, long cache_timeout, time_t now) 
+hostcache_prune(struct Curl_hash *hostcache, long cache_timeout, time_t now)
 {
   struct hostcache_prune_data user;
 
@@ -334,7 +334,7 @@ Curl_fetch_addr(struct connectdata *conn,
 
 #ifndef CURL_DISABLE_SHUFFLE_DNS
 UNITTEST CURLcode Curl_shuffle_addr(struct Curl_easy *data,
-                                    struct Curl_addrinfo **addr); 
+                                    struct Curl_addrinfo **addr);
 /*
  * Curl_shuffle_addr() shuffles the order of addresses in a 'Curl_addrinfo'
  * struct by re-linking its linked list.
@@ -348,13 +348,13 @@ UNITTEST CURLcode Curl_shuffle_addr(struct Curl_easy *data,
  * @unittest: 1608
  */
 UNITTEST CURLcode Curl_shuffle_addr(struct Curl_easy *data,
-                                    struct Curl_addrinfo **addr) 
+                                    struct Curl_addrinfo **addr)
 {
   CURLcode result = CURLE_OK;
   const int num_addrs = Curl_num_addresses(*addr);
 
   if(num_addrs > 1) {
-    struct Curl_addrinfo **nodes; 
+    struct Curl_addrinfo **nodes;
     infof(data, "Shuffling %i addresses", num_addrs);
 
     nodes = malloc(num_addrs*sizeof(*nodes));
@@ -373,7 +373,7 @@ UNITTEST CURLcode Curl_shuffle_addr(struct Curl_easy *data,
       if(rnd) {
         /* Fisher-Yates shuffle */
         if(Curl_rand(data, (unsigned char *)rnd, rnd_size) == CURLE_OK) {
-          struct Curl_addrinfo *swap_tmp; 
+          struct Curl_addrinfo *swap_tmp;
           for(i = num_addrs - 1; i > 0; i--) {
             swap_tmp = nodes[rnd[i] % (i + 1)];
             nodes[rnd[i] % (i + 1)] = nodes[i];
@@ -412,7 +412,7 @@ UNITTEST CURLcode Curl_shuffle_addr(struct Curl_easy *data,
  */
 struct Curl_dns_entry *
 Curl_cache_addr(struct Curl_easy *data,
-                struct Curl_addrinfo *addr, 
+                struct Curl_addrinfo *addr,
                 const char *hostname,
                 int port)
 {
@@ -480,19 +480,19 @@ Curl_cache_addr(struct Curl_easy *data,
  * CURLRESOLV_PENDING  (1) = waiting for response, no pointer
  */
 
-enum resolve_t Curl_resolv(struct connectdata *conn, 
-                           const char *hostname, 
-                           int port, 
-                           bool allowDOH, 
-                           struct Curl_dns_entry **entry) 
+enum resolve_t Curl_resolv(struct connectdata *conn,
+                           const char *hostname,
+                           int port,
+                           bool allowDOH,
+                           struct Curl_dns_entry **entry)
 {
   struct Curl_dns_entry *dns = NULL;
   struct Curl_easy *data = conn->data;
   CURLcode result;
-  enum resolve_t rc = CURLRESOLV_ERROR; /* default to failure */ 
+  enum resolve_t rc = CURLRESOLV_ERROR; /* default to failure */
 
   *entry = NULL;
-  conn->bits.doh = FALSE; /* default is not */ 
+  conn->bits.doh = FALSE; /* default is not */
 
   if(data->share)
     Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
@@ -511,13 +511,13 @@ enum resolve_t Curl_resolv(struct connectdata *conn,
   if(!dns) {
     /* The entry was not in the cache. Resolve it to IP address */
 
-    struct Curl_addrinfo *addr = NULL; 
+    struct Curl_addrinfo *addr = NULL;
     int respwait = 0;
-    struct in_addr in; 
-#ifndef USE_RESOLVE_ON_IPS 
-    const 
-#endif 
-      bool ipnum = FALSE; 
+    struct in_addr in;
+#ifndef USE_RESOLVE_ON_IPS
+    const
+#endif
+      bool ipnum = FALSE;
 
     /* notify the resolver start callback */
     if(data->set.resolver_start) {
@@ -530,59 +530,59 @@ enum resolve_t Curl_resolv(struct connectdata *conn,
         return CURLRESOLV_ERROR;
     }
 
-#ifndef USE_RESOLVE_ON_IPS 
-    /* First check if this is an IPv4 address string */ 
-    if(Curl_inet_pton(AF_INET, hostname, &in) > 0) 
-      /* This is a dotted IP address 123.123.123.123-style */ 
-      addr = Curl_ip2addr(AF_INET, &in, hostname, port); 
-#ifdef ENABLE_IPV6 
-    if(!addr) { 
-      struct in6_addr in6; 
-      /* check if this is an IPv6 address string */ 
-      if(Curl_inet_pton(AF_INET6, hostname, &in6) > 0) 
-        /* This is an IPv6 address literal */ 
-        addr = Curl_ip2addr(AF_INET6, &in6, hostname, port); 
+#ifndef USE_RESOLVE_ON_IPS
+    /* First check if this is an IPv4 address string */
+    if(Curl_inet_pton(AF_INET, hostname, &in) > 0)
+      /* This is a dotted IP address 123.123.123.123-style */
+      addr = Curl_ip2addr(AF_INET, &in, hostname, port);
+#ifdef ENABLE_IPV6
+    if(!addr) {
+      struct in6_addr in6;
+      /* check if this is an IPv6 address string */
+      if(Curl_inet_pton(AF_INET6, hostname, &in6) > 0)
+        /* This is an IPv6 address literal */
+        addr = Curl_ip2addr(AF_INET6, &in6, hostname, port);
     }
-#endif /* ENABLE_IPV6 */ 
- 
-#else /* if USE_RESOLVE_ON_IPS */ 
-    /* First check if this is an IPv4 address string */ 
-    if(Curl_inet_pton(AF_INET, hostname, &in) > 0) 
-      /* This is a dotted IP address 123.123.123.123-style */ 
-      ipnum = TRUE; 
-#ifdef ENABLE_IPV6 
+#endif /* ENABLE_IPV6 */
+
+#else /* if USE_RESOLVE_ON_IPS */
+    /* First check if this is an IPv4 address string */
+    if(Curl_inet_pton(AF_INET, hostname, &in) > 0)
+      /* This is a dotted IP address 123.123.123.123-style */
+      ipnum = TRUE;
+#ifdef ENABLE_IPV6
     else {
-      struct in6_addr in6; 
-      /* check if this is an IPv6 address string */ 
-      if(Curl_inet_pton(AF_INET6, hostname, &in6) > 0) 
-        /* This is an IPv6 address literal */ 
-        ipnum = TRUE; 
-    } 
-#endif /* ENABLE_IPV6 */ 
- 
-#endif /* !USE_RESOLVE_ON_IPS */ 
- 
-    if(!addr) { 
-      /* Check what IP specifics the app has requested and if we can provide 
-       * it. If not, bail out. */ 
-      if(!Curl_ipvalid(conn)) 
-        return CURLRESOLV_ERROR; 
- 
-      if(allowDOH && data->set.doh && !ipnum) { 
-        addr = Curl_doh(conn, hostname, port, &respwait); 
-      } 
-      else { 
-        /* If Curl_getaddrinfo() returns NULL, 'respwait' might be set to a 
-           non-zero value indicating that we need to wait for the response to 
-           the resolve call */ 
-        addr = Curl_getaddrinfo(conn, 
+      struct in6_addr in6;
+      /* check if this is an IPv6 address string */
+      if(Curl_inet_pton(AF_INET6, hostname, &in6) > 0)
+        /* This is an IPv6 address literal */
+        ipnum = TRUE;
+    }
+#endif /* ENABLE_IPV6 */
+
+#endif /* !USE_RESOLVE_ON_IPS */
+
+    if(!addr) {
+      /* Check what IP specifics the app has requested and if we can provide
+       * it. If not, bail out. */
+      if(!Curl_ipvalid(conn))
+        return CURLRESOLV_ERROR;
+
+      if(allowDOH && data->set.doh && !ipnum) {
+        addr = Curl_doh(conn, hostname, port, &respwait);
+      }
+      else {
+        /* If Curl_getaddrinfo() returns NULL, 'respwait' might be set to a
+           non-zero value indicating that we need to wait for the response to
+           the resolve call */
+        addr = Curl_getaddrinfo(conn,
 #ifdef DEBUGBUILD
-                                (data->set.str[STRING_DEVICE] 
-                                 && !strcmp(data->set.str[STRING_DEVICE], 
-                                            "LocalHost"))?"localhost": 
+                                (data->set.str[STRING_DEVICE]
+                                 && !strcmp(data->set.str[STRING_DEVICE],
+                                            "LocalHost"))?"localhost":
 #endif
-                                hostname, port, &respwait); 
-      } 
+                                hostname, port, &respwait);
+      }
     }
     if(!addr) {
       if(respwait) {
@@ -658,11 +658,11 @@ RETSIGTYPE alarmfunc(int sig)
  * CURLRESOLV_PENDING  (1) = waiting for response, no pointer
  */
 
-enum resolve_t Curl_resolv_timeout(struct connectdata *conn, 
-                                   const char *hostname, 
-                                   int port, 
-                                   struct Curl_dns_entry **entry, 
-                                   timediff_t timeoutms) 
+enum resolve_t Curl_resolv_timeout(struct connectdata *conn,
+                                   const char *hostname,
+                                   int port,
+                                   struct Curl_dns_entry **entry,
+                                   timediff_t timeoutms)
 {
 #ifdef USE_ALARM_TIMEOUT
 #ifdef HAVE_SIGACTION
@@ -678,7 +678,7 @@ enum resolve_t Curl_resolv_timeout(struct connectdata *conn,
   volatile unsigned int prev_alarm = 0;
   struct Curl_easy *data = conn->data;
 #endif /* USE_ALARM_TIMEOUT */
-  enum resolve_t rc; 
+  enum resolve_t rc;
 
   *entry = NULL;
 
@@ -787,7 +787,7 @@ clean_up:
                                             conn->created) / 1000;
 
     /* the alarm period is counted in even number of seconds */
-    unsigned long alarm_set = (unsigned long)(prev_alarm - elapsed_secs); 
+    unsigned long alarm_set = (unsigned long)(prev_alarm - elapsed_secs);
 
     if(!alarm_set ||
        ((alarm_set >= 0x80000000) && (prev_alarm < 0x80000000)) ) {
@@ -843,7 +843,7 @@ static void freednsentry(void *freethis)
 /*
  * Curl_mk_dnscache() inits a new DNS cache and returns success/failure.
  */
-int Curl_mk_dnscache(struct Curl_hash *hash) 
+int Curl_mk_dnscache(struct Curl_hash *hash)
 {
   return Curl_hash_init(hash, 7, Curl_hash_str, Curl_str_key_compare,
                         freednsentry);
@@ -857,7 +857,7 @@ int Curl_mk_dnscache(struct Curl_hash *hash)
  */
 
 void Curl_hostcache_clean(struct Curl_easy *data,
-                          struct Curl_hash *hash) 
+                          struct Curl_hash *hash)
 {
   if(data && data->share)
     Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
@@ -906,7 +906,7 @@ CURLcode Curl_loadhostpairs(struct Curl_easy *data)
     }
     else {
       struct Curl_dns_entry *dns;
-      struct Curl_addrinfo *head = NULL, *tail = NULL; 
+      struct Curl_addrinfo *head = NULL, *tail = NULL;
       size_t entry_len;
       char address[64];
 #if !defined(CURL_DISABLE_VERBOSE_STRINGS)
@@ -940,7 +940,7 @@ CURLcode Curl_loadhostpairs(struct Curl_easy *data)
 
       while(*end_ptr) {
         size_t alen;
-        struct Curl_addrinfo *ai; 
+        struct Curl_addrinfo *ai;
 
         addr_begin = end_ptr + 1;
         addr_end = strchr(addr_begin, ',');
@@ -1059,11 +1059,11 @@ CURLcode Curl_loadhostpairs(struct Curl_easy *data)
 CURLcode Curl_resolv_check(struct connectdata *conn,
                            struct Curl_dns_entry **dns)
 {
-#if defined(CURL_DISABLE_DOH) && !defined(CURLRES_ASYNCH) 
-  (void)dns; 
-#endif 
- 
-  if(conn->bits.doh) 
+#if defined(CURL_DISABLE_DOH) && !defined(CURLRES_ASYNCH)
+  (void)dns;
+#endif
+
+  if(conn->bits.doh)
     return Curl_doh_is_resolved(conn, dns);
   return Curl_resolver_is_resolved(conn, dns);
 }
@@ -1072,7 +1072,7 @@ int Curl_resolv_getsock(struct connectdata *conn,
                         curl_socket_t *socks)
 {
 #ifdef CURLRES_ASYNCH
-  if(conn->bits.doh) 
+  if(conn->bits.doh)
     /* nothing to wait for during DOH resolve, those handles have their own
        sockets */
     return GETSOCK_BLANK;
@@ -1101,12 +1101,12 @@ CURLcode Curl_once_resolved(struct connectdata *conn,
 
   result = Curl_setup_conn(conn, protocol_done);
 
-  if(result) { 
-    struct Curl_easy *data = conn->data; 
-    DEBUGASSERT(data); 
-    Curl_detach_connnection(data); 
-    Curl_conncache_remove_conn(data, conn, TRUE); 
-    Curl_disconnect(data, conn, TRUE); 
-  } 
+  if(result) {
+    struct Curl_easy *data = conn->data;
+    DEBUGASSERT(data);
+    Curl_detach_connnection(data);
+    Curl_conncache_remove_conn(data, conn, TRUE);
+    Curl_disconnect(data, conn, TRUE);
+  }
   return result;
 }