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

1 files changed, 157 insertions, 157 deletions

diff --git a/contrib/libs/curl/lib/urlapi.c b/contrib/libs/curl/lib/urlapi.c
index ae75963595..535bd9d909 100644
--- a/contrib/libs/curl/lib/urlapi.c
+++ b/contrib/libs/curl/lib/urlapi.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
@@ -64,7 +64,7 @@ struct Curl_URL {
   char *fragment;
 
   char *scratch; /* temporary scratch area */
-  char *temppath; /* temporary path pointer */
+  char *temppath; /* temporary path pointer */ 
   long portnum; /* the numerical version */
 };
 
@@ -83,7 +83,7 @@ static void free_urlhandle(struct Curl_URL *u)
   free(u->query);
   free(u->fragment);
   free(u->scratch);
-  free(u->temppath);
+  free(u->temppath); 
 }
 
 /* move the full contents of one handle onto another and
@@ -225,7 +225,7 @@ static void strcpy_url(char *output, const char *url, bool relative)
       break;
     }
   }
-  *optr = 0; /* null-terminate output buffer */
+  *optr = 0; /* null-terminate output buffer */ 
 
 }
 
@@ -353,7 +353,7 @@ static char *concat_url(const char *base, const char *relurl)
   else {
     /* We got a new absolute path for this server */
 
-    if(relurl[1] == '/') {
+    if(relurl[1] == '/') { 
       /* the new URL starts with //, just keep the protocol part from the
          original one */
       *protsep = 0;
@@ -436,7 +436,7 @@ static CURLUcode parse_hostname_login(struct Curl_URL *u,
   char *userp = NULL;
   char *passwdp = NULL;
   char *optionsp = NULL;
-  const struct Curl_handler *h = NULL;
+  const struct Curl_handler *h = NULL; 
 
   /* At this point, we're hoping all the other special cases have
    * been taken care of, so conn->host.name is at most
@@ -456,10 +456,10 @@ static CURLUcode parse_hostname_login(struct Curl_URL *u,
    * ftp://user:password@ftp.my.site:8021/README */
   *hostname = ++ptr;
 
-  /* if this is a known scheme, get some details */
-  if(u->scheme)
-    h = Curl_builtin_scheme(u->scheme);
-
+  /* if this is a known scheme, get some details */ 
+  if(u->scheme) 
+    h = Curl_builtin_scheme(u->scheme); 
+ 
   /* We could use the login information in the URL so extract it. Only parse
      options if the handler says we should. Note that 'h' might be NULL! */
   ccode = Curl_parse_login_details(login, ptr - login - 1,
@@ -497,8 +497,8 @@ static CURLUcode parse_hostname_login(struct Curl_URL *u,
   return result;
 }
 
-UNITTEST CURLUcode Curl_parse_port(struct Curl_URL *u, char *hostname,
-                                   bool has_scheme)
+UNITTEST CURLUcode Curl_parse_port(struct Curl_URL *u, char *hostname, 
+                                   bool has_scheme) 
 {
   char *portptr = NULL;
   char endbracket;
@@ -543,14 +543,14 @@ UNITTEST CURLUcode Curl_parse_port(struct Curl_URL *u, char *hostname,
 
     /* Browser behavior adaptation. If there's a colon with no digits after,
        just cut off the name there which makes us ignore the colon and just
-       use the default port. Firefox, Chrome and Safari all do that.
-
-       Don't do it if the URL has no scheme, to make something that looks like
-       a scheme not work!
-    */
+       use the default port. Firefox, Chrome and Safari all do that. 
+ 
+       Don't do it if the URL has no scheme, to make something that looks like 
+       a scheme not work! 
+    */ 
     if(!portptr[1]) {
       *portptr = '\0';
-      return has_scheme ? CURLUE_OK : CURLUE_BAD_PORT_NUMBER;
+      return has_scheme ? CURLUE_OK : CURLUE_BAD_PORT_NUMBER; 
     }
 
     if(!ISDIGIT(portptr[1]))
@@ -580,7 +580,7 @@ UNITTEST CURLUcode Curl_parse_port(struct Curl_URL *u, char *hostname,
 }
 
 /* scan for byte values < 31 or 127 */
-static CURLUcode junkscan(const char *part)
+static CURLUcode junkscan(const char *part) 
 {
   if(part) {
     static const char badbytes[]={
@@ -589,7 +589,7 @@ static CURLUcode junkscan(const char *part)
       0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
       0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
       0x7f,
-      0x00 /* null-terminate */
+      0x00 /* null-terminate */ 
     };
     size_t n = strlen(part);
     size_t nfine = strcspn(part, badbytes);
@@ -607,12 +607,12 @@ static CURLUcode hostname_check(struct Curl_URL *u, char *hostname)
   size_t hlen = strlen(hostname);
 
   if(hostname[0] == '[') {
-#ifdef ENABLE_IPV6
+#ifdef ENABLE_IPV6 
     char dest[16]; /* fits a binary IPv6 address */
-#endif
+#endif 
     const char *l = "0123456789abcdefABCDEF:.";
-    if(hlen < 4) /* '[::]' is the shortest possible valid string */
-      return CURLUE_MALFORMED_INPUT;
+    if(hlen < 4) /* '[::]' is the shortest possible valid string */ 
+      return CURLUE_MALFORMED_INPUT; 
     hostname++;
     hlen -= 2;
 
@@ -677,7 +677,7 @@ static CURLUcode seturl(const char *url, CURLU *u, unsigned int flags)
   CURLUcode result;
   bool url_has_scheme = FALSE;
   char schemebuf[MAX_SCHEME_LEN + 1];
-  const char *schemep = NULL;
+  const char *schemep = NULL; 
   size_t schemelen = 0;
   size_t urllen;
 
@@ -798,7 +798,7 @@ static CURLUcode seturl(const char *url, CURLU *u, unsigned int flags)
 
       if(junkscan(schemep))
         return CURLUE_MALFORMED_INPUT;
-
+ 
     }
     else {
       /* no scheme! */
@@ -806,7 +806,7 @@ static CURLUcode seturl(const char *url, CURLU *u, unsigned int flags)
       if(!(flags & (CURLU_DEFAULT_SCHEME|CURLU_GUESS_SCHEME)))
         return CURLUE_MALFORMED_INPUT;
       if(flags & CURLU_DEFAULT_SCHEME)
-        schemep = DEFAULT_SCHEME;
+        schemep = DEFAULT_SCHEME; 
 
       /*
        * The URL was badly formatted, let's try without scheme specified.
@@ -819,83 +819,83 @@ static CURLUcode seturl(const char *url, CURLU *u, unsigned int flags)
       p++;
 
     len = p - hostp;
-    if(len) {
-      memcpy(hostname, hostp, len);
-      hostname[len] = 0;
-    }
-    else {
-      if(!(flags & CURLU_NO_AUTHORITY))
-        return CURLUE_MALFORMED_INPUT;
+    if(len) { 
+      memcpy(hostname, hostp, len); 
+      hostname[len] = 0; 
     }
+    else { 
+      if(!(flags & CURLU_NO_AUTHORITY)) 
+        return CURLUE_MALFORMED_INPUT; 
+    } 
 
     len = strlen(p);
     memcpy(path, p, len);
     path[len] = 0;
 
-    if(schemep) {
-      u->scheme = strdup(schemep);
-      if(!u->scheme)
-        return CURLUE_OUT_OF_MEMORY;
-    }
+    if(schemep) { 
+      u->scheme = strdup(schemep); 
+      if(!u->scheme) 
+        return CURLUE_OUT_OF_MEMORY; 
+    } 
   }
 
   if(junkscan(path))
     return CURLUE_MALFORMED_INPUT;
 
-  if((flags & CURLU_URLENCODE) && path[0]) {
-    /* worst case output length is 3x the original! */
-    char *newp = malloc(strlen(path) * 3);
-    if(!newp)
-      return CURLUE_OUT_OF_MEMORY;
-    path_alloced = TRUE;
-    strcpy_url(newp, path, TRUE); /* consider it relative */
-    u->temppath = path = newp;
-  }
-
-  fragment = strchr(path, '#');
-  if(fragment) {
-    *fragment++ = 0;
-    if(fragment[0]) {
-      u->fragment = strdup(fragment);
-      if(!u->fragment)
-        return CURLUE_OUT_OF_MEMORY;
-    }
-  }
-
+  if((flags & CURLU_URLENCODE) && path[0]) { 
+    /* worst case output length is 3x the original! */ 
+    char *newp = malloc(strlen(path) * 3); 
+    if(!newp) 
+      return CURLUE_OUT_OF_MEMORY; 
+    path_alloced = TRUE; 
+    strcpy_url(newp, path, TRUE); /* consider it relative */ 
+    u->temppath = path = newp; 
+  } 
+ 
+  fragment = strchr(path, '#'); 
+  if(fragment) { 
+    *fragment++ = 0; 
+    if(fragment[0]) { 
+      u->fragment = strdup(fragment); 
+      if(!u->fragment) 
+        return CURLUE_OUT_OF_MEMORY; 
+    } 
+  } 
+ 
   query = strchr(path, '?');
-  if(query) {
+  if(query) { 
     *query++ = 0;
-    /* done even if the query part is a blank string */
-    u->query = strdup(query);
-    if(!u->query)
-      return CURLUE_OUT_OF_MEMORY;
-  }
+    /* done even if the query part is a blank string */ 
+    u->query = strdup(query); 
+    if(!u->query) 
+      return CURLUE_OUT_OF_MEMORY; 
+  } 
 
   if(!path[0])
-    /* if there's no path left set, unset */
+    /* if there's no path left set, unset */ 
     path = NULL;
-  else {
-    if(!(flags & CURLU_PATH_AS_IS)) {
-      /* remove ../ and ./ sequences according to RFC3986 */
-      char *newp = Curl_dedotdotify(path);
-      if(!newp)
-        return CURLUE_OUT_OF_MEMORY;
-
-      if(strcmp(newp, path)) {
-        /* if we got a new version */
-        if(path_alloced)
-          Curl_safefree(u->temppath);
-        u->temppath = path = newp;
-        path_alloced = TRUE;
-      }
-      else
-        free(newp);
+  else { 
+    if(!(flags & CURLU_PATH_AS_IS)) { 
+      /* remove ../ and ./ sequences according to RFC3986 */ 
+      char *newp = Curl_dedotdotify(path); 
+      if(!newp) 
+        return CURLUE_OUT_OF_MEMORY; 
+
+      if(strcmp(newp, path)) { 
+        /* if we got a new version */ 
+        if(path_alloced) 
+          Curl_safefree(u->temppath); 
+        u->temppath = path = newp; 
+        path_alloced = TRUE; 
+      } 
+      else 
+        free(newp); 
     }
-
+ 
     u->path = path_alloced?path:strdup(path);
     if(!u->path)
       return CURLUE_OUT_OF_MEMORY;
-    u->temppath = NULL; /* used now */
+    u->temppath = NULL; /* used now */ 
   }
 
   if(hostname) {
@@ -905,52 +905,52 @@ static CURLUcode seturl(const char *url, CURLU *u, unsigned int flags)
     if(junkscan(hostname))
       return CURLUE_MALFORMED_INPUT;
 
-    result = parse_hostname_login(u, &hostname, flags);
+    result = parse_hostname_login(u, &hostname, flags); 
     if(result)
       return result;
 
-    result = Curl_parse_port(u, hostname, url_has_scheme);
+    result = Curl_parse_port(u, hostname, url_has_scheme); 
     if(result)
       return result;
 
-    if(0 == strlen(hostname) && (flags & CURLU_NO_AUTHORITY)) {
-      /* Skip hostname check, it's allowed to be empty. */
-    }
-    else {
-      result = hostname_check(u, hostname);
-      if(result)
-        return result;
-    }
+    if(0 == strlen(hostname) && (flags & CURLU_NO_AUTHORITY)) { 
+      /* Skip hostname check, it's allowed to be empty. */ 
+    } 
+    else { 
+      result = hostname_check(u, hostname); 
+      if(result) 
+        return result; 
+    } 
 
     u->host = strdup(hostname);
     if(!u->host)
       return CURLUE_OUT_OF_MEMORY;
 
-    if((flags & CURLU_GUESS_SCHEME) && !schemep) {
-      /* legacy curl-style guess based on host name */
-      if(checkprefix("ftp.", hostname))
-        schemep = "ftp";
-      else if(checkprefix("dict.", hostname))
-        schemep = "dict";
-      else if(checkprefix("ldap.", hostname))
-        schemep = "ldap";
-      else if(checkprefix("imap.", hostname))
-        schemep = "imap";
-      else if(checkprefix("smtp.", hostname))
-        schemep = "smtp";
-      else if(checkprefix("pop3.", hostname))
-        schemep = "pop3";
-      else
-        schemep = "http";
-
-      u->scheme = strdup(schemep);
-      if(!u->scheme)
-        return CURLUE_OUT_OF_MEMORY;
-    }
+    if((flags & CURLU_GUESS_SCHEME) && !schemep) { 
+      /* legacy curl-style guess based on host name */ 
+      if(checkprefix("ftp.", hostname)) 
+        schemep = "ftp"; 
+      else if(checkprefix("dict.", hostname)) 
+        schemep = "dict"; 
+      else if(checkprefix("ldap.", hostname)) 
+        schemep = "ldap"; 
+      else if(checkprefix("imap.", hostname)) 
+        schemep = "imap"; 
+      else if(checkprefix("smtp.", hostname)) 
+        schemep = "smtp"; 
+      else if(checkprefix("pop3.", hostname)) 
+        schemep = "pop3"; 
+      else 
+        schemep = "http"; 
+ 
+      u->scheme = strdup(schemep); 
+      if(!u->scheme) 
+        return CURLUE_OUT_OF_MEMORY; 
+    } 
   }
 
-  Curl_safefree(u->scratch);
-  Curl_safefree(u->temppath);
+  Curl_safefree(u->scratch); 
+  Curl_safefree(u->temppath); 
 
   return CURLUE_OK;
 }
@@ -1115,23 +1115,23 @@ CURLUcode curl_url_get(CURLU *u, CURLUPart what,
       else
         return CURLUE_NO_SCHEME;
 
-      h = Curl_builtin_scheme(scheme);
-      if(!port && (flags & CURLU_DEFAULT_PORT)) {
-        /* there's no stored port number, but asked to deliver
-           a default one for the scheme */
-        if(h) {
-          msnprintf(portbuf, sizeof(portbuf), "%ld", h->defport);
-          port = portbuf;
+      h = Curl_builtin_scheme(scheme); 
+      if(!port && (flags & CURLU_DEFAULT_PORT)) { 
+        /* there's no stored port number, but asked to deliver 
+           a default one for the scheme */ 
+        if(h) { 
+          msnprintf(portbuf, sizeof(portbuf), "%ld", h->defport); 
+          port = portbuf; 
         }
       }
-      else if(port) {
-        /* there is a stored port number, but asked to inhibit if it matches
-           the default one for the scheme */
-        if(h && (h->defport == u->portnum) &&
-           (flags & CURLU_NO_DEFAULT_PORT))
-          port = NULL;
-      }
-
+      else if(port) { 
+        /* there is a stored port number, but asked to inhibit if it matches 
+           the default one for the scheme */ 
+        if(h && (h->defport == u->portnum) && 
+           (flags & CURLU_NO_DEFAULT_PORT)) 
+          port = NULL; 
+      } 
+ 
       if(h && !(h->flags & PROTOPT_URLOPTIONS))
         options = NULL;
 
@@ -1190,10 +1190,10 @@ CURLUcode curl_url_get(CURLU *u, CURLUPart what,
     if(urldecode) {
       char *decoded;
       size_t dlen;
-      /* this unconditional rejection of control bytes is documented
-         API behavior */
-      CURLcode res = Curl_urldecode(NULL, *part, 0, &decoded, &dlen,
-                                    REJECT_CTRL);
+      /* this unconditional rejection of control bytes is documented 
+         API behavior */ 
+      CURLcode res = Curl_urldecode(NULL, *part, 0, &decoded, &dlen, 
+                                    REJECT_CTRL); 
       free(*part);
       if(res) {
         *part = NULL;
@@ -1260,7 +1260,7 @@ CURLUcode curl_url_set(CURLU *u, CURLUPart what,
       return CURLUE_UNKNOWN_PART;
     }
     if(storep && *storep) {
-      Curl_safefree(*storep);
+      Curl_safefree(*storep); 
     }
     return CURLUE_OK;
   }
@@ -1288,7 +1288,7 @@ CURLUcode curl_url_set(CURLU *u, CURLUPart what,
     break;
   case CURLUPART_HOST:
     storep = &u->host;
-    Curl_safefree(u->zoneid);
+    Curl_safefree(u->zoneid); 
     break;
   case CURLUPART_ZONEID:
     storep = &u->zoneid;
@@ -1380,8 +1380,8 @@ CURLUcode curl_url_set(CURLU *u, CURLUPart what,
   default:
     return CURLUE_UNKNOWN_PART;
   }
-  DEBUGASSERT(storep);
-  {
+  DEBUGASSERT(storep); 
+  { 
     const char *newp = part;
     size_t nalloc = strlen(part);
 
@@ -1395,14 +1395,14 @@ CURLUcode curl_url_set(CURLU *u, CURLUPart what,
       char *enc = malloc(nalloc * 3 + 1); /* for worst case! */
       if(!enc)
         return CURLUE_OUT_OF_MEMORY;
-      for(i = (const unsigned char *)part, o = enc; *i; i++) {
-        if((*i == ' ') && plusencode) {
-          *o = '+';
-          o++;
+      for(i = (const unsigned char *)part, o = enc; *i; i++) { 
+        if((*i == ' ') && plusencode) { 
+          *o = '+'; 
+          o++; 
         }
-        else if(Curl_isunreserved(*i) ||
-                ((*i == '/') && urlskipslash) ||
-                ((*i == '=') && equalsencode)) {
+        else if(Curl_isunreserved(*i) || 
+                ((*i == '/') && urlskipslash) || 
+                ((*i == '=') && equalsencode)) { 
           if((*i == '=') && equalsencode)
             /* only skip the first equals sign */
             equalsencode = FALSE;
@@ -1414,7 +1414,7 @@ CURLUcode curl_url_set(CURLU *u, CURLUPart what,
           o += 3;
         }
       }
-      *o = 0; /* null-terminate */
+      *o = 0; /* null-terminate */ 
       newp = enc;
     }
     else {
@@ -1460,15 +1460,15 @@ CURLUcode curl_url_set(CURLU *u, CURLUPart what,
     }
 
     if(what == CURLUPART_HOST) {
-      if(0 == strlen(newp) && (flags & CURLU_NO_AUTHORITY)) {
-        /* Skip hostname check, it's allowed to be empty. */
-      }
-      else {
-        if(hostname_check(u, (char *)newp)) {
-          free((char *)newp);
-          return CURLUE_MALFORMED_INPUT;
-        }
+      if(0 == strlen(newp) && (flags & CURLU_NO_AUTHORITY)) { 
+        /* Skip hostname check, it's allowed to be empty. */ 
       }
+      else { 
+        if(hostname_check(u, (char *)newp)) { 
+          free((char *)newp); 
+          return CURLUE_MALFORMED_INPUT; 
+        } 
+      } 
     }
 
     free(*storep);