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

1 files changed, 1200 insertions, 1200 deletions

diff --git a/contrib/libs/curl/lib/urlapi.c b/contrib/libs/curl/lib/urlapi.c
index 6cc8651f05..ae75963595 100644
--- a/contrib/libs/curl/lib/urlapi.c
+++ b/contrib/libs/curl/lib/urlapi.c
@@ -1,546 +1,546 @@
-/*************************************************************************** 
- *                                  _   _ ____  _ 
- *  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" 
- 
-#include "urldata.h" 
-#include "urlapi-int.h" 
-#include "strcase.h" 
-#include "dotdot.h" 
-#include "url.h" 
-#include "escape.h" 
-#include "curl_ctype.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 "urldata.h"
+#include "urlapi-int.h"
+#include "strcase.h"
+#include "dotdot.h"
+#include "url.h"
+#include "escape.h"
+#include "curl_ctype.h"
 #include "inet_pton.h"
- 
-/* The last 3 #include files should be in this order */ 
-#include "curl_printf.h" 
-#include "curl_memory.h" 
-#include "memdebug.h" 
- 
-  /* MSDOS/Windows style drive prefix, eg c: in c:foo */ 
-#define STARTS_WITH_DRIVE_PREFIX(str) \ 
-  ((('a' <= str[0] && str[0] <= 'z') || \ 
-    ('A' <= str[0] && str[0] <= 'Z')) && \ 
-   (str[1] == ':')) 
- 
-  /* MSDOS/Windows style drive prefix, optionally with 
-   * a '|' instead of ':', followed by a slash or NUL */ 
-#define STARTS_WITH_URL_DRIVE_PREFIX(str) \ 
-  ((('a' <= (str)[0] && (str)[0] <= 'z') || \ 
-    ('A' <= (str)[0] && (str)[0] <= 'Z')) && \ 
-   ((str)[1] == ':' || (str)[1] == '|') && \ 
-   ((str)[2] == '/' || (str)[2] == '\\' || (str)[2] == 0)) 
- 
-/* Internal representation of CURLU. Point to URL-encoded strings. */ 
-struct Curl_URL { 
-  char *scheme; 
-  char *user; 
-  char *password; 
-  char *options; /* IMAP only? */ 
-  char *host; 
+
+/* The last 3 #include files should be in this order */
+#include "curl_printf.h"
+#include "curl_memory.h"
+#include "memdebug.h"
+
+  /* MSDOS/Windows style drive prefix, eg c: in c:foo */
+#define STARTS_WITH_DRIVE_PREFIX(str) \
+  ((('a' <= str[0] && str[0] <= 'z') || \
+    ('A' <= str[0] && str[0] <= 'Z')) && \
+   (str[1] == ':'))
+
+  /* MSDOS/Windows style drive prefix, optionally with
+   * a '|' instead of ':', followed by a slash or NUL */
+#define STARTS_WITH_URL_DRIVE_PREFIX(str) \
+  ((('a' <= (str)[0] && (str)[0] <= 'z') || \
+    ('A' <= (str)[0] && (str)[0] <= 'Z')) && \
+   ((str)[1] == ':' || (str)[1] == '|') && \
+   ((str)[2] == '/' || (str)[2] == '\\' || (str)[2] == 0))
+
+/* Internal representation of CURLU. Point to URL-encoded strings. */
+struct Curl_URL {
+  char *scheme;
+  char *user;
+  char *password;
+  char *options; /* IMAP only? */
+  char *host;
   char *zoneid; /* for numerical IPv6 addresses */
-  char *port; 
-  char *path; 
-  char *query; 
-  char *fragment; 
- 
-  char *scratch; /* temporary scratch area */ 
+  char *port;
+  char *path;
+  char *query;
+  char *fragment;
+
+  char *scratch; /* temporary scratch area */
   char *temppath; /* temporary path pointer */
-  long portnum; /* the numerical version */ 
-}; 
- 
-#define DEFAULT_SCHEME "https" 
- 
-static void free_urlhandle(struct Curl_URL *u) 
-{ 
-  free(u->scheme); 
-  free(u->user); 
-  free(u->password); 
-  free(u->options); 
-  free(u->host); 
+  long portnum; /* the numerical version */
+};
+
+#define DEFAULT_SCHEME "https"
+
+static void free_urlhandle(struct Curl_URL *u)
+{
+  free(u->scheme);
+  free(u->user);
+  free(u->password);
+  free(u->options);
+  free(u->host);
   free(u->zoneid);
-  free(u->port); 
-  free(u->path); 
-  free(u->query); 
-  free(u->fragment); 
-  free(u->scratch); 
+  free(u->port);
+  free(u->path);
+  free(u->query);
+  free(u->fragment);
+  free(u->scratch);
   free(u->temppath);
-} 
- 
-/* move the full contents of one handle onto another and 
-   free the original */ 
-static void mv_urlhandle(struct Curl_URL *from, 
-                         struct Curl_URL *to) 
-{ 
-  free_urlhandle(to); 
-  *to = *from; 
-  free(from); 
-} 
- 
-/* 
- * Find the separator at the end of the host name, or the '?' in cases like 
- * http://www.url.com?id=2380 
- */ 
-static const char *find_host_sep(const char *url) 
-{ 
-  const char *sep; 
-  const char *query; 
- 
-  /* Find the start of the hostname */ 
-  sep = strstr(url, "//"); 
-  if(!sep) 
-    sep = url; 
-  else 
-    sep += 2; 
- 
-  query = strchr(sep, '?'); 
-  sep = strchr(sep, '/'); 
- 
-  if(!sep) 
-    sep = url + strlen(url); 
- 
-  if(!query) 
-    query = url + strlen(url); 
- 
-  return sep < query ? sep : query; 
-} 
- 
-/* 
- * Decide in an encoding-independent manner whether a character in an 
- * URL must be escaped. The same criterion must be used in strlen_url() 
- * and strcpy_url(). 
- */ 
-static bool urlchar_needs_escaping(int c) 
-{ 
-    return !(ISCNTRL(c) || ISSPACE(c) || ISGRAPH(c)); 
-} 
- 
-/* 
- * strlen_url() returns the length of the given URL if the spaces within the 
- * URL were properly URL encoded. 
- * URL encoding should be skipped for host names, otherwise IDN resolution 
- * will fail. 
- */ 
+}
+
+/* move the full contents of one handle onto another and
+   free the original */
+static void mv_urlhandle(struct Curl_URL *from,
+                         struct Curl_URL *to)
+{
+  free_urlhandle(to);
+  *to = *from;
+  free(from);
+}
+
+/*
+ * Find the separator at the end of the host name, or the '?' in cases like
+ * http://www.url.com?id=2380
+ */
+static const char *find_host_sep(const char *url)
+{
+  const char *sep;
+  const char *query;
+
+  /* Find the start of the hostname */
+  sep = strstr(url, "//");
+  if(!sep)
+    sep = url;
+  else
+    sep += 2;
+
+  query = strchr(sep, '?');
+  sep = strchr(sep, '/');
+
+  if(!sep)
+    sep = url + strlen(url);
+
+  if(!query)
+    query = url + strlen(url);
+
+  return sep < query ? sep : query;
+}
+
+/*
+ * Decide in an encoding-independent manner whether a character in an
+ * URL must be escaped. The same criterion must be used in strlen_url()
+ * and strcpy_url().
+ */
+static bool urlchar_needs_escaping(int c)
+{
+    return !(ISCNTRL(c) || ISSPACE(c) || ISGRAPH(c));
+}
+
+/*
+ * strlen_url() returns the length of the given URL if the spaces within the
+ * URL were properly URL encoded.
+ * URL encoding should be skipped for host names, otherwise IDN resolution
+ * will fail.
+ */
 static size_t strlen_url(const char *url, bool relative)
-{ 
-  const unsigned char *ptr; 
-  size_t newlen = 0; 
-  bool left = TRUE; /* left side of the ? */ 
-  const unsigned char *host_sep = (const unsigned char *) url; 
- 
-  if(!relative) 
-    host_sep = (const unsigned char *) find_host_sep(url); 
- 
-  for(ptr = (unsigned char *)url; *ptr; ptr++) { 
- 
-    if(ptr < host_sep) { 
-      ++newlen; 
-      continue; 
-    } 
- 
-    switch(*ptr) { 
-    case '?': 
-      left = FALSE; 
-      /* FALLTHROUGH */ 
-    default: 
-      if(urlchar_needs_escaping(*ptr)) 
-        newlen += 2; 
-      newlen++; 
-      break; 
-    case ' ': 
-      if(left) 
-        newlen += 3; 
-      else 
-        newlen++; 
-      break; 
-    } 
-  } 
-  return newlen; 
-} 
- 
-/* strcpy_url() copies a url to a output buffer and URL-encodes the spaces in 
- * the source URL accordingly. 
- * URL encoding should be skipped for host names, otherwise IDN resolution 
- * will fail. 
- */ 
+{
+  const unsigned char *ptr;
+  size_t newlen = 0;
+  bool left = TRUE; /* left side of the ? */
+  const unsigned char *host_sep = (const unsigned char *) url;
+
+  if(!relative)
+    host_sep = (const unsigned char *) find_host_sep(url);
+
+  for(ptr = (unsigned char *)url; *ptr; ptr++) {
+
+    if(ptr < host_sep) {
+      ++newlen;
+      continue;
+    }
+
+    switch(*ptr) {
+    case '?':
+      left = FALSE;
+      /* FALLTHROUGH */
+    default:
+      if(urlchar_needs_escaping(*ptr))
+        newlen += 2;
+      newlen++;
+      break;
+    case ' ':
+      if(left)
+        newlen += 3;
+      else
+        newlen++;
+      break;
+    }
+  }
+  return newlen;
+}
+
+/* strcpy_url() copies a url to a output buffer and URL-encodes the spaces in
+ * the source URL accordingly.
+ * URL encoding should be skipped for host names, otherwise IDN resolution
+ * will fail.
+ */
 static void strcpy_url(char *output, const char *url, bool relative)
-{ 
-  /* we must add this with whitespace-replacing */ 
-  bool left = TRUE; 
-  const unsigned char *iptr; 
-  char *optr = output; 
-  const unsigned char *host_sep = (const unsigned char *) url; 
- 
-  if(!relative) 
-    host_sep = (const unsigned char *) find_host_sep(url); 
- 
-  for(iptr = (unsigned char *)url;    /* read from here */ 
-      *iptr;         /* until zero byte */ 
-      iptr++) { 
- 
-    if(iptr < host_sep) { 
-      *optr++ = *iptr; 
-      continue; 
-    } 
- 
-    switch(*iptr) { 
-    case '?': 
-      left = FALSE; 
-      /* FALLTHROUGH */ 
-    default: 
-      if(urlchar_needs_escaping(*iptr)) { 
-        msnprintf(optr, 4, "%%%02x", *iptr); 
-        optr += 3; 
-      } 
-      else 
-        *optr++=*iptr; 
-      break; 
-    case ' ': 
-      if(left) { 
-        *optr++='%'; /* add a '%' */ 
-        *optr++='2'; /* add a '2' */ 
-        *optr++='0'; /* add a '0' */ 
-      } 
-      else 
-        *optr++='+'; /* add a '+' here */ 
-      break; 
-    } 
-  } 
+{
+  /* we must add this with whitespace-replacing */
+  bool left = TRUE;
+  const unsigned char *iptr;
+  char *optr = output;
+  const unsigned char *host_sep = (const unsigned char *) url;
+
+  if(!relative)
+    host_sep = (const unsigned char *) find_host_sep(url);
+
+  for(iptr = (unsigned char *)url;    /* read from here */
+      *iptr;         /* until zero byte */
+      iptr++) {
+
+    if(iptr < host_sep) {
+      *optr++ = *iptr;
+      continue;
+    }
+
+    switch(*iptr) {
+    case '?':
+      left = FALSE;
+      /* FALLTHROUGH */
+    default:
+      if(urlchar_needs_escaping(*iptr)) {
+        msnprintf(optr, 4, "%%%02x", *iptr);
+        optr += 3;
+      }
+      else
+        *optr++=*iptr;
+      break;
+    case ' ':
+      if(left) {
+        *optr++='%'; /* add a '%' */
+        *optr++='2'; /* add a '2' */
+        *optr++='0'; /* add a '0' */
+      }
+      else
+        *optr++='+'; /* add a '+' here */
+      break;
+    }
+  }
   *optr = 0; /* null-terminate output buffer */
- 
-} 
- 
-/* 
- * Returns true if the given URL is absolute (as opposed to relative) within 
- * the buffer size. Returns the scheme in the buffer if TRUE and 'buf' is 
- * non-NULL. 
- */ 
-bool Curl_is_absolute_url(const char *url, char *buf, size_t buflen) 
-{ 
-  size_t i; 
-#ifdef WIN32 
-  if(STARTS_WITH_DRIVE_PREFIX(url)) 
-    return FALSE; 
-#endif 
-  for(i = 0; i < buflen && url[i]; ++i) { 
-    char s = url[i]; 
-    if((s == ':') && (url[i + 1] == '/')) { 
-      if(buf) 
-        buf[i] = 0; 
-      return TRUE; 
-    } 
-    /* RFC 3986 3.1 explains: 
-      scheme      = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) 
-    */ 
-    else if(ISALNUM(s) || (s == '+') || (s == '-') || (s == '.') ) { 
-      if(buf) 
-        buf[i] = (char)TOLOWER(s); 
-    } 
-    else 
-      break; 
-  } 
-  return FALSE; 
-} 
- 
-/* 
- * Concatenate a relative URL to a base URL making it absolute. 
- * URL-encodes any spaces. 
- * The returned pointer must be freed by the caller unless NULL 
- * (returns NULL on out of memory). 
- */ 
+
+}
+
+/*
+ * Returns true if the given URL is absolute (as opposed to relative) within
+ * the buffer size. Returns the scheme in the buffer if TRUE and 'buf' is
+ * non-NULL.
+ */
+bool Curl_is_absolute_url(const char *url, char *buf, size_t buflen)
+{
+  size_t i;
+#ifdef WIN32
+  if(STARTS_WITH_DRIVE_PREFIX(url))
+    return FALSE;
+#endif
+  for(i = 0; i < buflen && url[i]; ++i) {
+    char s = url[i];
+    if((s == ':') && (url[i + 1] == '/')) {
+      if(buf)
+        buf[i] = 0;
+      return TRUE;
+    }
+    /* RFC 3986 3.1 explains:
+      scheme      = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
+    */
+    else if(ISALNUM(s) || (s == '+') || (s == '-') || (s == '.') ) {
+      if(buf)
+        buf[i] = (char)TOLOWER(s);
+    }
+    else
+      break;
+  }
+  return FALSE;
+}
+
+/*
+ * Concatenate a relative URL to a base URL making it absolute.
+ * URL-encodes any spaces.
+ * The returned pointer must be freed by the caller unless NULL
+ * (returns NULL on out of memory).
+ */
 static char *concat_url(const char *base, const char *relurl)
-{ 
-  /*** 
-   TRY to append this new path to the old URL 
-   to the right of the host part. Oh crap, this is doomed to cause 
-   problems in the future... 
-  */ 
-  char *newest; 
-  char *protsep; 
-  char *pathsep; 
-  size_t newlen; 
-  bool host_changed = FALSE; 
- 
-  const char *useurl = relurl; 
-  size_t urllen; 
- 
-  /* we must make our own copy of the URL to play with, as it may 
-     point to read-only data */ 
-  char *url_clone = strdup(base); 
- 
-  if(!url_clone) 
-    return NULL; /* skip out of this NOW */ 
- 
-  /* protsep points to the start of the host name */ 
-  protsep = strstr(url_clone, "//"); 
-  if(!protsep) 
-    protsep = url_clone; 
-  else 
-    protsep += 2; /* pass the slashes */ 
- 
-  if('/' != relurl[0]) { 
-    int level = 0; 
- 
-    /* First we need to find out if there's a ?-letter in the URL, 
-       and cut it and the right-side of that off */ 
-    pathsep = strchr(protsep, '?'); 
-    if(pathsep) 
-      *pathsep = 0; 
- 
-    /* we have a relative path to append to the last slash if there's one 
-       available, or if the new URL is just a query string (starts with a 
-       '?')  we append the new one at the end of the entire currently worked 
-       out URL */ 
-    if(useurl[0] != '?') { 
-      pathsep = strrchr(protsep, '/'); 
-      if(pathsep) 
-        *pathsep = 0; 
-    } 
- 
-    /* Check if there's any slash after the host name, and if so, remember 
-       that position instead */ 
-    pathsep = strchr(protsep, '/'); 
-    if(pathsep) 
-      protsep = pathsep + 1; 
-    else 
-      protsep = NULL; 
- 
-    /* now deal with one "./" or any amount of "../" in the newurl 
-       and act accordingly */ 
- 
-    if((useurl[0] == '.') && (useurl[1] == '/')) 
-      useurl += 2; /* just skip the "./" */ 
- 
-    while((useurl[0] == '.') && 
-          (useurl[1] == '.') && 
-          (useurl[2] == '/')) { 
-      level++; 
-      useurl += 3; /* pass the "../" */ 
-    } 
- 
-    if(protsep) { 
-      while(level--) { 
-        /* cut off one more level from the right of the original URL */ 
-        pathsep = strrchr(protsep, '/'); 
-        if(pathsep) 
-          *pathsep = 0; 
-        else { 
-          *protsep = 0; 
-          break; 
-        } 
-      } 
-    } 
-  } 
-  else { 
-    /* We got a new absolute path for this server */ 
- 
+{
+  /***
+   TRY to append this new path to the old URL
+   to the right of the host part. Oh crap, this is doomed to cause
+   problems in the future...
+  */
+  char *newest;
+  char *protsep;
+  char *pathsep;
+  size_t newlen;
+  bool host_changed = FALSE;
+
+  const char *useurl = relurl;
+  size_t urllen;
+
+  /* we must make our own copy of the URL to play with, as it may
+     point to read-only data */
+  char *url_clone = strdup(base);
+
+  if(!url_clone)
+    return NULL; /* skip out of this NOW */
+
+  /* protsep points to the start of the host name */
+  protsep = strstr(url_clone, "//");
+  if(!protsep)
+    protsep = url_clone;
+  else
+    protsep += 2; /* pass the slashes */
+
+  if('/' != relurl[0]) {
+    int level = 0;
+
+    /* First we need to find out if there's a ?-letter in the URL,
+       and cut it and the right-side of that off */
+    pathsep = strchr(protsep, '?');
+    if(pathsep)
+      *pathsep = 0;
+
+    /* we have a relative path to append to the last slash if there's one
+       available, or if the new URL is just a query string (starts with a
+       '?')  we append the new one at the end of the entire currently worked
+       out URL */
+    if(useurl[0] != '?') {
+      pathsep = strrchr(protsep, '/');
+      if(pathsep)
+        *pathsep = 0;
+    }
+
+    /* Check if there's any slash after the host name, and if so, remember
+       that position instead */
+    pathsep = strchr(protsep, '/');
+    if(pathsep)
+      protsep = pathsep + 1;
+    else
+      protsep = NULL;
+
+    /* now deal with one "./" or any amount of "../" in the newurl
+       and act accordingly */
+
+    if((useurl[0] == '.') && (useurl[1] == '/'))
+      useurl += 2; /* just skip the "./" */
+
+    while((useurl[0] == '.') &&
+          (useurl[1] == '.') &&
+          (useurl[2] == '/')) {
+      level++;
+      useurl += 3; /* pass the "../" */
+    }
+
+    if(protsep) {
+      while(level--) {
+        /* cut off one more level from the right of the original URL */
+        pathsep = strrchr(protsep, '/');
+        if(pathsep)
+          *pathsep = 0;
+        else {
+          *protsep = 0;
+          break;
+        }
+      }
+    }
+  }
+  else {
+    /* We got a new absolute path for this server */
+
     if(relurl[1] == '/') {
-      /* the new URL starts with //, just keep the protocol part from the 
-         original one */ 
-      *protsep = 0; 
-      useurl = &relurl[2]; /* we keep the slashes from the original, so we 
-                              skip the new ones */ 
-      host_changed = TRUE; 
-    } 
-    else { 
-      /* cut off the original URL from the first slash, or deal with URLs 
-         without slash */ 
-      pathsep = strchr(protsep, '/'); 
-      if(pathsep) { 
-        /* When people use badly formatted URLs, such as 
-           "http://www.url.com?dir=/home/daniel" we must not use the first 
-           slash, if there's a ?-letter before it! */ 
-        char *sep = strchr(protsep, '?'); 
-        if(sep && (sep < pathsep)) 
-          pathsep = sep; 
-        *pathsep = 0; 
-      } 
-      else { 
-        /* There was no slash. Now, since we might be operating on a badly 
-           formatted URL, such as "http://www.url.com?id=2380" which doesn't 
-           use a slash separator as it is supposed to, we need to check for a 
-           ?-letter as well! */ 
-        pathsep = strchr(protsep, '?'); 
-        if(pathsep) 
-          *pathsep = 0; 
-      } 
-    } 
-  } 
- 
-  /* If the new part contains a space, this is a mighty stupid redirect 
-     but we still make an effort to do "right". To the left of a '?' 
-     letter we replace each space with %20 while it is replaced with '+' 
-     on the right side of the '?' letter. 
-  */ 
+      /* the new URL starts with //, just keep the protocol part from the
+         original one */
+      *protsep = 0;
+      useurl = &relurl[2]; /* we keep the slashes from the original, so we
+                              skip the new ones */
+      host_changed = TRUE;
+    }
+    else {
+      /* cut off the original URL from the first slash, or deal with URLs
+         without slash */
+      pathsep = strchr(protsep, '/');
+      if(pathsep) {
+        /* When people use badly formatted URLs, such as
+           "http://www.url.com?dir=/home/daniel" we must not use the first
+           slash, if there's a ?-letter before it! */
+        char *sep = strchr(protsep, '?');
+        if(sep && (sep < pathsep))
+          pathsep = sep;
+        *pathsep = 0;
+      }
+      else {
+        /* There was no slash. Now, since we might be operating on a badly
+           formatted URL, such as "http://www.url.com?id=2380" which doesn't
+           use a slash separator as it is supposed to, we need to check for a
+           ?-letter as well! */
+        pathsep = strchr(protsep, '?');
+        if(pathsep)
+          *pathsep = 0;
+      }
+    }
+  }
+
+  /* If the new part contains a space, this is a mighty stupid redirect
+     but we still make an effort to do "right". To the left of a '?'
+     letter we replace each space with %20 while it is replaced with '+'
+     on the right side of the '?' letter.
+  */
   newlen = strlen_url(useurl, !host_changed);
- 
-  urllen = strlen(url_clone); 
- 
-  newest = malloc(urllen + 1 + /* possible slash */ 
-                  newlen + 1 /* zero byte */); 
- 
-  if(!newest) { 
-    free(url_clone); /* don't leak this */ 
-    return NULL; 
-  } 
- 
-  /* copy over the root url part */ 
-  memcpy(newest, url_clone, urllen); 
- 
-  /* check if we need to append a slash */ 
-  if(('/' == useurl[0]) || (protsep && !*protsep) || ('?' == useurl[0])) 
-    ; 
-  else 
-    newest[urllen++]='/'; 
- 
-  /* then append the new piece on the right side */ 
+
+  urllen = strlen(url_clone);
+
+  newest = malloc(urllen + 1 + /* possible slash */
+                  newlen + 1 /* zero byte */);
+
+  if(!newest) {
+    free(url_clone); /* don't leak this */
+    return NULL;
+  }
+
+  /* copy over the root url part */
+  memcpy(newest, url_clone, urllen);
+
+  /* check if we need to append a slash */
+  if(('/' == useurl[0]) || (protsep && !*protsep) || ('?' == useurl[0]))
+    ;
+  else
+    newest[urllen++]='/';
+
+  /* then append the new piece on the right side */
   strcpy_url(&newest[urllen], useurl, !host_changed);
- 
-  free(url_clone); 
- 
-  return newest; 
-} 
- 
-/* 
- * parse_hostname_login() 
- * 
- * Parse the login details (user name, password and options) from the URL and 
- * strip them out of the host name 
- * 
- */ 
-static CURLUcode parse_hostname_login(struct Curl_URL *u, 
-                                      char **hostname, 
-                                      unsigned int flags) 
-{ 
-  CURLUcode result = CURLUE_OK; 
-  CURLcode ccode; 
-  char *userp = NULL; 
-  char *passwdp = NULL; 
-  char *optionsp = NULL; 
+
+  free(url_clone);
+
+  return newest;
+}
+
+/*
+ * parse_hostname_login()
+ *
+ * Parse the login details (user name, password and options) from the URL and
+ * strip them out of the host name
+ *
+ */
+static CURLUcode parse_hostname_login(struct Curl_URL *u,
+                                      char **hostname,
+                                      unsigned int flags)
+{
+  CURLUcode result = CURLUE_OK;
+  CURLcode ccode;
+  char *userp = NULL;
+  char *passwdp = NULL;
+  char *optionsp = 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 
-   *    [user[:password][;options]]@]hostname 
-   * 
-   * We need somewhere to put the embedded details, so do that first. 
-   */ 
- 
-  char *ptr = strchr(*hostname, '@'); 
-  char *login = *hostname; 
- 
-  if(!ptr) 
-    goto out; 
- 
-  /* We will now try to extract the 
-   * possible login information in a string like: 
-   * ftp://user:password@ftp.my.site:8021/README */ 
-  *hostname = ++ptr; 
- 
+
+  /* At this point, we're hoping all the other special cases have
+   * been taken care of, so conn->host.name is at most
+   *    [user[:password][;options]]@]hostname
+   *
+   * We need somewhere to put the embedded details, so do that first.
+   */
+
+  char *ptr = strchr(*hostname, '@');
+  char *login = *hostname;
+
+  if(!ptr)
+    goto out;
+
+  /* We will now try to extract the
+   * possible login information in a string like:
+   * 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);
 
-  /* 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, 
-                                   &userp, &passwdp, 
-                                   (h && (h->flags & PROTOPT_URLOPTIONS)) ? 
-                                   &optionsp:NULL); 
-  if(ccode) { 
-    result = CURLUE_MALFORMED_INPUT; 
-    goto out; 
-  } 
- 
-  if(userp) { 
-    if(flags & CURLU_DISALLOW_USER) { 
-      /* Option DISALLOW_USER is set and url contains username. */ 
-      result = CURLUE_USER_NOT_ALLOWED; 
-      goto out; 
-    } 
- 
-    u->user = userp; 
-  } 
- 
-  if(passwdp) 
-    u->password = passwdp; 
- 
-  if(optionsp) 
-    u->options = optionsp; 
- 
-  return CURLUE_OK; 
-  out: 
- 
-  free(userp); 
-  free(passwdp); 
-  free(optionsp); 
- 
-  return result; 
-} 
- 
+  /* 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,
+                                   &userp, &passwdp,
+                                   (h && (h->flags & PROTOPT_URLOPTIONS)) ?
+                                   &optionsp:NULL);
+  if(ccode) {
+    result = CURLUE_MALFORMED_INPUT;
+    goto out;
+  }
+
+  if(userp) {
+    if(flags & CURLU_DISALLOW_USER) {
+      /* Option DISALLOW_USER is set and url contains username. */
+      result = CURLUE_USER_NOT_ALLOWED;
+      goto out;
+    }
+
+    u->user = userp;
+  }
+
+  if(passwdp)
+    u->password = passwdp;
+
+  if(optionsp)
+    u->options = optionsp;
+
+  return CURLUE_OK;
+  out:
+
+  free(userp);
+  free(passwdp);
+  free(optionsp);
+
+  return result;
+}
+
 UNITTEST CURLUcode Curl_parse_port(struct Curl_URL *u, char *hostname,
                                    bool has_scheme)
-{ 
-  char *portptr = NULL; 
-  char endbracket; 
-  int len; 
- 
-  /* 
-   * Find the end of an IPv6 address, either on the ']' ending bracket or 
-   * a percent-encoded zone index. 
-   */ 
-  if(1 == sscanf(hostname, "[%*45[0123456789abcdefABCDEF:.]%c%n", 
-                 &endbracket, &len)) { 
-    if(']' == endbracket) 
-      portptr = &hostname[len]; 
-    else if('%' == endbracket) { 
-      int zonelen = len; 
+{
+  char *portptr = NULL;
+  char endbracket;
+  int len;
+
+  /*
+   * Find the end of an IPv6 address, either on the ']' ending bracket or
+   * a percent-encoded zone index.
+   */
+  if(1 == sscanf(hostname, "[%*45[0123456789abcdefABCDEF:.]%c%n",
+                 &endbracket, &len)) {
+    if(']' == endbracket)
+      portptr = &hostname[len];
+    else if('%' == endbracket) {
+      int zonelen = len;
       if(1 == sscanf(hostname + zonelen, "%*[^]]%c%n", &endbracket, &len)) {
         if(']' != endbracket)
           return CURLUE_MALFORMED_INPUT;
         portptr = &hostname[--zonelen + len + 1];
       }
-      else 
-        return CURLUE_MALFORMED_INPUT; 
-    } 
-    else 
-      return CURLUE_MALFORMED_INPUT; 
- 
-    /* this is a RFC2732-style specified IP-address */ 
-    if(portptr && *portptr) { 
-      if(*portptr != ':') 
-        return CURLUE_MALFORMED_INPUT; 
-    } 
-    else 
-      portptr = NULL; 
-  } 
-  else 
-    portptr = strchr(hostname, ':'); 
- 
-  if(portptr) { 
-    char *rest; 
-    long port; 
-    char portbuf[7]; 
- 
+      else
+        return CURLUE_MALFORMED_INPUT;
+    }
+    else
+      return CURLUE_MALFORMED_INPUT;
+
+    /* this is a RFC2732-style specified IP-address */
+    if(portptr && *portptr) {
+      if(*portptr != ':')
+        return CURLUE_MALFORMED_INPUT;
+    }
+    else
+      portptr = NULL;
+  }
+  else
+    portptr = strchr(hostname, ':');
+
+  if(portptr) {
+    char *rest;
+    long port;
+    char portbuf[7];
+
     /* 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.
@@ -553,19 +553,19 @@ UNITTEST CURLUcode Curl_parse_port(struct Curl_URL *u, char *hostname,
       return has_scheme ? CURLUE_OK : CURLUE_BAD_PORT_NUMBER;
     }
 
-    if(!ISDIGIT(portptr[1])) 
-      return CURLUE_BAD_PORT_NUMBER; 
- 
-    port = strtol(portptr + 1, &rest, 10);  /* Port number must be decimal */ 
- 
-    if((port <= 0) || (port > 0xffff)) 
-      /* Single unix standard says port numbers are 16 bits long, but we don't 
-         treat port zero as OK. */ 
-      return CURLUE_BAD_PORT_NUMBER; 
- 
-    if(rest[0]) 
-      return CURLUE_BAD_PORT_NUMBER; 
- 
+    if(!ISDIGIT(portptr[1]))
+      return CURLUE_BAD_PORT_NUMBER;
+
+    port = strtol(portptr + 1, &rest, 10);  /* Port number must be decimal */
+
+    if((port <= 0) || (port > 0xffff))
+      /* Single unix standard says port numbers are 16 bits long, but we don't
+         treat port zero as OK. */
+      return CURLUE_BAD_PORT_NUMBER;
+
+    if(rest[0])
+      return CURLUE_BAD_PORT_NUMBER;
+
     *portptr++ = '\0'; /* cut off the name there */
     *rest = 0;
     /* generate a new port number string to get rid of leading zeroes etc */
@@ -574,15 +574,15 @@ UNITTEST CURLUcode Curl_parse_port(struct Curl_URL *u, char *hostname,
     u->port = strdup(portbuf);
     if(!u->port)
       return CURLUE_OUT_OF_MEMORY;
-  } 
- 
-  return CURLUE_OK; 
-} 
- 
-/* scan for byte values < 31 or 127 */ 
+  }
+
+  return CURLUE_OK;
+}
+
+/* scan for byte values < 31 or 127 */
 static CURLUcode junkscan(const char *part)
-{ 
-  if(part) { 
+{
+  if(part) {
     static const char badbytes[]={
       /* */ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
       0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
@@ -591,36 +591,36 @@ static CURLUcode junkscan(const char *part)
       0x7f,
       0x00 /* null-terminate */
     };
-    size_t n = strlen(part); 
-    size_t nfine = strcspn(part, badbytes); 
-    if(nfine != n) 
-      /* since we don't know which part is scanned, return a generic error 
-         code */ 
-      return CURLUE_MALFORMED_INPUT; 
-  } 
-  return CURLUE_OK; 
-} 
- 
+    size_t n = strlen(part);
+    size_t nfine = strcspn(part, badbytes);
+    if(nfine != n)
+      /* since we don't know which part is scanned, return a generic error
+         code */
+      return CURLUE_MALFORMED_INPUT;
+  }
+  return CURLUE_OK;
+}
+
 static CURLUcode hostname_check(struct Curl_URL *u, char *hostname)
-{ 
-  size_t len; 
-  size_t hlen = strlen(hostname); 
- 
-  if(hostname[0] == '[') { 
+{
+  size_t len;
+  size_t hlen = strlen(hostname);
+
+  if(hostname[0] == '[') {
 #ifdef ENABLE_IPV6
     char dest[16]; /* fits a binary IPv6 address */
 #endif
     const char *l = "0123456789abcdefABCDEF:.";
     if(hlen < 4) /* '[::]' is the shortest possible valid string */
       return CURLUE_MALFORMED_INPUT;
-    hostname++; 
-    hlen -= 2; 
- 
+    hostname++;
+    hlen -= 2;
+
     if(hostname[hlen] != ']')
       return CURLUE_MALFORMED_INPUT;
 
-    /* only valid letters are ok */ 
-    len = strspn(hostname, l); 
+    /* only valid letters are ok */
+    len = strspn(hostname, l);
     if(hlen != len) {
       hlen = len;
       if(hostname[len] == '%') {
@@ -649,199 +649,199 @@ static CURLUcode hostname_check(struct Curl_URL *u, char *hostname)
 #ifdef ENABLE_IPV6
     hostname[hlen] = 0; /* end the address there */
     if(1 != Curl_inet_pton(AF_INET6, hostname, dest))
-      return CURLUE_MALFORMED_INPUT; 
+      return CURLUE_MALFORMED_INPUT;
     hostname[hlen] = ']'; /* restore ending bracket */
 #endif
-  } 
-  else { 
-    /* letters from the second string is not ok */ 
-    len = strcspn(hostname, " "); 
-    if(hlen != len) 
-      /* hostname with bad content */ 
-      return CURLUE_MALFORMED_INPUT; 
-  } 
+  }
+  else {
+    /* letters from the second string is not ok */
+    len = strcspn(hostname, " ");
+    if(hlen != len)
+      /* hostname with bad content */
+      return CURLUE_MALFORMED_INPUT;
+  }
   if(!hostname[0])
     return CURLUE_NO_HOST;
-  return CURLUE_OK; 
-} 
- 
-#define HOSTNAME_END(x) (((x) == '/') || ((x) == '?') || ((x) == '#')) 
- 
-static CURLUcode seturl(const char *url, CURLU *u, unsigned int flags) 
-{ 
-  char *path; 
-  bool path_alloced = FALSE; 
-  char *hostname; 
-  char *query = NULL; 
-  char *fragment = NULL; 
-  CURLUcode result; 
-  bool url_has_scheme = FALSE; 
+  return CURLUE_OK;
+}
+
+#define HOSTNAME_END(x) (((x) == '/') || ((x) == '?') || ((x) == '#'))
+
+static CURLUcode seturl(const char *url, CURLU *u, unsigned int flags)
+{
+  char *path;
+  bool path_alloced = FALSE;
+  char *hostname;
+  char *query = NULL;
+  char *fragment = NULL;
+  CURLUcode result;
+  bool url_has_scheme = FALSE;
   char schemebuf[MAX_SCHEME_LEN + 1];
   const char *schemep = NULL;
-  size_t schemelen = 0; 
-  size_t urllen; 
- 
-  if(!url) 
-    return CURLUE_MALFORMED_INPUT; 
- 
-  /************************************************************* 
-   * Parse the URL. 
-   ************************************************************/ 
-  /* allocate scratch area */ 
-  urllen = strlen(url); 
+  size_t schemelen = 0;
+  size_t urllen;
+
+  if(!url)
+    return CURLUE_MALFORMED_INPUT;
+
+  /*************************************************************
+   * Parse the URL.
+   ************************************************************/
+  /* allocate scratch area */
+  urllen = strlen(url);
   if(urllen > CURL_MAX_INPUT_LENGTH)
     /* excessive input length */
     return CURLUE_MALFORMED_INPUT;
 
-  path = u->scratch = malloc(urllen * 2 + 2); 
-  if(!path) 
-    return CURLUE_OUT_OF_MEMORY; 
- 
-  hostname = &path[urllen + 1]; 
-  hostname[0] = 0; 
- 
-  if(Curl_is_absolute_url(url, schemebuf, sizeof(schemebuf))) { 
-    url_has_scheme = TRUE; 
-    schemelen = strlen(schemebuf); 
-  } 
- 
-  /* handle the file: scheme */ 
-  if(url_has_scheme && strcasecompare(schemebuf, "file")) { 
-    /* path has been allocated large enough to hold this */ 
-    strcpy(path, &url[5]); 
- 
-    hostname = NULL; /* no host for file: URLs */ 
-    u->scheme = strdup("file"); 
-    if(!u->scheme) 
-      return CURLUE_OUT_OF_MEMORY; 
- 
-    /* Extra handling URLs with an authority component (i.e. that start with 
-     * "file://") 
-     * 
-     * We allow omitted hostname (e.g. file:/<path>) -- valid according to 
-     * RFC 8089, but not the (current) WHAT-WG URL spec. 
-     */ 
-    if(path[0] == '/' && path[1] == '/') { 
-      /* swallow the two slashes */ 
-      char *ptr = &path[2]; 
- 
-      /* 
-       * According to RFC 8089, a file: URL can be reliably dereferenced if: 
-       * 
-       *  o it has no/blank hostname, or 
-       * 
-       *  o the hostname matches "localhost" (case-insensitively), or 
-       * 
-       *  o the hostname is a FQDN that resolves to this machine. 
-       * 
-       * For brevity, we only consider URLs with empty, "localhost", or 
-       * "127.0.0.1" hostnames as local. 
-       * 
-       * Additionally, there is an exception for URLs with a Windows drive 
-       * letter in the authority (which was accidentally omitted from RFC 8089 
-       * Appendix E, but believe me, it was meant to be there. --MK) 
-       */ 
-      if(ptr[0] != '/' && !STARTS_WITH_URL_DRIVE_PREFIX(ptr)) { 
-        /* the URL includes a host name, it must match "localhost" or 
-           "127.0.0.1" to be valid */ 
-        if(!checkprefix("localhost/", ptr) && 
-           !checkprefix("127.0.0.1/", ptr)) { 
-          /* Invalid file://hostname/, expected localhost or 127.0.0.1 or 
-             none */ 
-          return CURLUE_MALFORMED_INPUT; 
-        } 
-        ptr += 9; /* now points to the slash after the host */ 
-      } 
- 
-      path = ptr; 
-    } 
- 
-#if !defined(MSDOS) && !defined(WIN32) && !defined(__CYGWIN__) 
-    /* Don't allow Windows drive letters when not in Windows. 
-     * This catches both "file:/c:" and "file:c:" */ 
-    if(('/' == path[0] && STARTS_WITH_URL_DRIVE_PREFIX(&path[1])) || 
-       STARTS_WITH_URL_DRIVE_PREFIX(path)) { 
-      /* File drive letters are only accepted in MSDOS/Windows */ 
-      return CURLUE_MALFORMED_INPUT; 
-    } 
-#else 
-    /* If the path starts with a slash and a drive letter, ditch the slash */ 
-    if('/' == path[0] && STARTS_WITH_URL_DRIVE_PREFIX(&path[1])) { 
-      /* This cannot be done with strcpy, as the memory chunks overlap! */ 
-      memmove(path, &path[1], strlen(&path[1]) + 1); 
-    } 
-#endif 
- 
-  } 
-  else { 
-    /* clear path */ 
-    const char *p; 
-    const char *hostp; 
-    size_t len; 
-    path[0] = 0; 
- 
-    if(url_has_scheme) { 
-      int i = 0; 
-      p = &url[schemelen + 1]; 
-      while(p && (*p == '/') && (i < 4)) { 
-        p++; 
-        i++; 
-      } 
-      if((i < 1) || (i>3)) 
-        /* less than one or more than three slashes */ 
-        return CURLUE_MALFORMED_INPUT; 
- 
-      schemep = schemebuf; 
-      if(!Curl_builtin_scheme(schemep) && 
-         !(flags & CURLU_NON_SUPPORT_SCHEME)) 
-        return CURLUE_UNSUPPORTED_SCHEME; 
- 
-      if(junkscan(schemep)) 
-        return CURLUE_MALFORMED_INPUT; 
-
-    } 
-    else { 
-      /* no scheme! */ 
- 
-      if(!(flags & (CURLU_DEFAULT_SCHEME|CURLU_GUESS_SCHEME))) 
-        return CURLUE_MALFORMED_INPUT; 
-      if(flags & CURLU_DEFAULT_SCHEME) 
+  path = u->scratch = malloc(urllen * 2 + 2);
+  if(!path)
+    return CURLUE_OUT_OF_MEMORY;
+
+  hostname = &path[urllen + 1];
+  hostname[0] = 0;
+
+  if(Curl_is_absolute_url(url, schemebuf, sizeof(schemebuf))) {
+    url_has_scheme = TRUE;
+    schemelen = strlen(schemebuf);
+  }
+
+  /* handle the file: scheme */
+  if(url_has_scheme && strcasecompare(schemebuf, "file")) {
+    /* path has been allocated large enough to hold this */
+    strcpy(path, &url[5]);
+
+    hostname = NULL; /* no host for file: URLs */
+    u->scheme = strdup("file");
+    if(!u->scheme)
+      return CURLUE_OUT_OF_MEMORY;
+
+    /* Extra handling URLs with an authority component (i.e. that start with
+     * "file://")
+     *
+     * We allow omitted hostname (e.g. file:/<path>) -- valid according to
+     * RFC 8089, but not the (current) WHAT-WG URL spec.
+     */
+    if(path[0] == '/' && path[1] == '/') {
+      /* swallow the two slashes */
+      char *ptr = &path[2];
+
+      /*
+       * According to RFC 8089, a file: URL can be reliably dereferenced if:
+       *
+       *  o it has no/blank hostname, or
+       *
+       *  o the hostname matches "localhost" (case-insensitively), or
+       *
+       *  o the hostname is a FQDN that resolves to this machine.
+       *
+       * For brevity, we only consider URLs with empty, "localhost", or
+       * "127.0.0.1" hostnames as local.
+       *
+       * Additionally, there is an exception for URLs with a Windows drive
+       * letter in the authority (which was accidentally omitted from RFC 8089
+       * Appendix E, but believe me, it was meant to be there. --MK)
+       */
+      if(ptr[0] != '/' && !STARTS_WITH_URL_DRIVE_PREFIX(ptr)) {
+        /* the URL includes a host name, it must match "localhost" or
+           "127.0.0.1" to be valid */
+        if(!checkprefix("localhost/", ptr) &&
+           !checkprefix("127.0.0.1/", ptr)) {
+          /* Invalid file://hostname/, expected localhost or 127.0.0.1 or
+             none */
+          return CURLUE_MALFORMED_INPUT;
+        }
+        ptr += 9; /* now points to the slash after the host */
+      }
+
+      path = ptr;
+    }
+
+#if !defined(MSDOS) && !defined(WIN32) && !defined(__CYGWIN__)
+    /* Don't allow Windows drive letters when not in Windows.
+     * This catches both "file:/c:" and "file:c:" */
+    if(('/' == path[0] && STARTS_WITH_URL_DRIVE_PREFIX(&path[1])) ||
+       STARTS_WITH_URL_DRIVE_PREFIX(path)) {
+      /* File drive letters are only accepted in MSDOS/Windows */
+      return CURLUE_MALFORMED_INPUT;
+    }
+#else
+    /* If the path starts with a slash and a drive letter, ditch the slash */
+    if('/' == path[0] && STARTS_WITH_URL_DRIVE_PREFIX(&path[1])) {
+      /* This cannot be done with strcpy, as the memory chunks overlap! */
+      memmove(path, &path[1], strlen(&path[1]) + 1);
+    }
+#endif
+
+  }
+  else {
+    /* clear path */
+    const char *p;
+    const char *hostp;
+    size_t len;
+    path[0] = 0;
+
+    if(url_has_scheme) {
+      int i = 0;
+      p = &url[schemelen + 1];
+      while(p && (*p == '/') && (i < 4)) {
+        p++;
+        i++;
+      }
+      if((i < 1) || (i>3))
+        /* less than one or more than three slashes */
+        return CURLUE_MALFORMED_INPUT;
+
+      schemep = schemebuf;
+      if(!Curl_builtin_scheme(schemep) &&
+         !(flags & CURLU_NON_SUPPORT_SCHEME))
+        return CURLUE_UNSUPPORTED_SCHEME;
+
+      if(junkscan(schemep))
+        return CURLUE_MALFORMED_INPUT;
+
+    }
+    else {
+      /* no scheme! */
+
+      if(!(flags & (CURLU_DEFAULT_SCHEME|CURLU_GUESS_SCHEME)))
+        return CURLUE_MALFORMED_INPUT;
+      if(flags & CURLU_DEFAULT_SCHEME)
         schemep = DEFAULT_SCHEME;
- 
-      /* 
-       * The URL was badly formatted, let's try without scheme specified. 
-       */ 
-      p = url; 
-    } 
-    hostp = p; /* host name starts here */ 
- 
-    while(*p && !HOSTNAME_END(*p)) /* find end of host name */ 
-      p++; 
- 
-    len = p - hostp; 
+
+      /*
+       * The URL was badly formatted, let's try without scheme specified.
+       */
+      p = url;
+    }
+    hostp = p; /* host name starts here */
+
+    while(*p && !HOSTNAME_END(*p)) /* find end of host name */
+      p++;
+
+    len = p - hostp;
     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; 
- 
+
+    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(junkscan(path)) 
-    return CURLUE_MALFORMED_INPUT; 
- 
+  }
+
+  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);
@@ -862,25 +862,25 @@ static CURLUcode seturl(const char *url, CURLU *u, unsigned int flags)
     }
   }
 
-  query = strchr(path, '?'); 
+  query = strchr(path, '?');
   if(query) {
-    *query++ = 0; 
+    *query++ = 0;
     /* 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(!path[0])
     /* if there's no path left set, unset */
-    path = NULL; 
+    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)
@@ -890,29 +890,29 @@ static CURLUcode seturl(const char *url, CURLU *u, unsigned int flags)
       }
       else
         free(newp);
-    } 
+    }
 
-    u->path = path_alloced?path:strdup(path); 
-    if(!u->path) 
-      return CURLUE_OUT_OF_MEMORY; 
+    u->path = path_alloced?path:strdup(path);
+    if(!u->path)
+      return CURLUE_OUT_OF_MEMORY;
     u->temppath = NULL; /* used now */
-  } 
- 
-  if(hostname) { 
-    /* 
-     * Parse the login details and strip them out of the host name. 
-     */ 
-    if(junkscan(hostname)) 
-      return CURLUE_MALFORMED_INPUT; 
- 
+  }
+
+  if(hostname) {
+    /*
+     * Parse the login details and strip them out of the host name.
+     */
+    if(junkscan(hostname))
+      return CURLUE_MALFORMED_INPUT;
+
     result = parse_hostname_login(u, &hostname, flags);
-    if(result) 
-      return result; 
- 
+    if(result)
+      return result;
+
     result = Curl_parse_port(u, hostname, url_has_scheme);
-    if(result) 
-      return result; 
- 
+    if(result)
+      return result;
+
     if(0 == strlen(hostname) && (flags & CURLU_NO_AUTHORITY)) {
       /* Skip hostname check, it's allowed to be empty. */
     }
@@ -921,11 +921,11 @@ static CURLUcode seturl(const char *url, CURLU *u, unsigned int flags)
       if(result)
         return result;
     }
- 
-    u->host = strdup(hostname); 
-    if(!u->host) 
-      return CURLUE_OUT_OF_MEMORY; 
- 
+
+    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))
@@ -947,174 +947,174 @@ static CURLUcode seturl(const char *url, CURLU *u, unsigned int flags)
       if(!u->scheme)
         return CURLUE_OUT_OF_MEMORY;
     }
-  } 
- 
+  }
+
   Curl_safefree(u->scratch);
   Curl_safefree(u->temppath);
- 
-  return CURLUE_OK; 
-} 
- 
-/* 
- * Parse the URL and set the relevant members of the Curl_URL struct. 
- */ 
-static CURLUcode parseurl(const char *url, CURLU *u, unsigned int flags) 
-{ 
-  CURLUcode result = seturl(url, u, flags); 
-  if(result) { 
-    free_urlhandle(u); 
-    memset(u, 0, sizeof(struct Curl_URL)); 
-  } 
-  return result; 
-} 
- 
-/* 
- */ 
-CURLU *curl_url(void) 
-{ 
-  return calloc(sizeof(struct Curl_URL), 1); 
-} 
- 
-void curl_url_cleanup(CURLU *u) 
-{ 
-  if(u) { 
-    free_urlhandle(u); 
-    free(u); 
-  } 
-} 
- 
-#define DUP(dest, src, name)         \ 
-  if(src->name) {                    \ 
-    dest->name = strdup(src->name);  \ 
-    if(!dest->name)                  \ 
-      goto fail;                     \ 
-  } 
- 
-CURLU *curl_url_dup(CURLU *in) 
-{ 
-  struct Curl_URL *u = calloc(sizeof(struct Curl_URL), 1); 
-  if(u) { 
-    DUP(u, in, scheme); 
-    DUP(u, in, user); 
-    DUP(u, in, password); 
-    DUP(u, in, options); 
-    DUP(u, in, host); 
-    DUP(u, in, port); 
-    DUP(u, in, path); 
-    DUP(u, in, query); 
-    DUP(u, in, fragment); 
-    u->portnum = in->portnum; 
-  } 
-  return u; 
-  fail: 
-  curl_url_cleanup(u); 
-  return NULL; 
-} 
- 
-CURLUcode curl_url_get(CURLU *u, CURLUPart what, 
-                       char **part, unsigned int flags) 
-{ 
-  char *ptr; 
-  CURLUcode ifmissing = CURLUE_UNKNOWN_PART; 
-  char portbuf[7]; 
-  bool urldecode = (flags & CURLU_URLDECODE)?1:0; 
-  bool plusdecode = FALSE; 
-  (void)flags; 
-  if(!u) 
-    return CURLUE_BAD_HANDLE; 
-  if(!part) 
-    return CURLUE_BAD_PARTPOINTER; 
-  *part = NULL; 
- 
-  switch(what) { 
-  case CURLUPART_SCHEME: 
-    ptr = u->scheme; 
-    ifmissing = CURLUE_NO_SCHEME; 
-    urldecode = FALSE; /* never for schemes */ 
-    break; 
-  case CURLUPART_USER: 
-    ptr = u->user; 
-    ifmissing = CURLUE_NO_USER; 
-    break; 
-  case CURLUPART_PASSWORD: 
-    ptr = u->password; 
-    ifmissing = CURLUE_NO_PASSWORD; 
-    break; 
-  case CURLUPART_OPTIONS: 
-    ptr = u->options; 
-    ifmissing = CURLUE_NO_OPTIONS; 
-    break; 
-  case CURLUPART_HOST: 
-    ptr = u->host; 
-    ifmissing = CURLUE_NO_HOST; 
-    break; 
+
+  return CURLUE_OK;
+}
+
+/*
+ * Parse the URL and set the relevant members of the Curl_URL struct.
+ */
+static CURLUcode parseurl(const char *url, CURLU *u, unsigned int flags)
+{
+  CURLUcode result = seturl(url, u, flags);
+  if(result) {
+    free_urlhandle(u);
+    memset(u, 0, sizeof(struct Curl_URL));
+  }
+  return result;
+}
+
+/*
+ */
+CURLU *curl_url(void)
+{
+  return calloc(sizeof(struct Curl_URL), 1);
+}
+
+void curl_url_cleanup(CURLU *u)
+{
+  if(u) {
+    free_urlhandle(u);
+    free(u);
+  }
+}
+
+#define DUP(dest, src, name)         \
+  if(src->name) {                    \
+    dest->name = strdup(src->name);  \
+    if(!dest->name)                  \
+      goto fail;                     \
+  }
+
+CURLU *curl_url_dup(CURLU *in)
+{
+  struct Curl_URL *u = calloc(sizeof(struct Curl_URL), 1);
+  if(u) {
+    DUP(u, in, scheme);
+    DUP(u, in, user);
+    DUP(u, in, password);
+    DUP(u, in, options);
+    DUP(u, in, host);
+    DUP(u, in, port);
+    DUP(u, in, path);
+    DUP(u, in, query);
+    DUP(u, in, fragment);
+    u->portnum = in->portnum;
+  }
+  return u;
+  fail:
+  curl_url_cleanup(u);
+  return NULL;
+}
+
+CURLUcode curl_url_get(CURLU *u, CURLUPart what,
+                       char **part, unsigned int flags)
+{
+  char *ptr;
+  CURLUcode ifmissing = CURLUE_UNKNOWN_PART;
+  char portbuf[7];
+  bool urldecode = (flags & CURLU_URLDECODE)?1:0;
+  bool plusdecode = FALSE;
+  (void)flags;
+  if(!u)
+    return CURLUE_BAD_HANDLE;
+  if(!part)
+    return CURLUE_BAD_PARTPOINTER;
+  *part = NULL;
+
+  switch(what) {
+  case CURLUPART_SCHEME:
+    ptr = u->scheme;
+    ifmissing = CURLUE_NO_SCHEME;
+    urldecode = FALSE; /* never for schemes */
+    break;
+  case CURLUPART_USER:
+    ptr = u->user;
+    ifmissing = CURLUE_NO_USER;
+    break;
+  case CURLUPART_PASSWORD:
+    ptr = u->password;
+    ifmissing = CURLUE_NO_PASSWORD;
+    break;
+  case CURLUPART_OPTIONS:
+    ptr = u->options;
+    ifmissing = CURLUE_NO_OPTIONS;
+    break;
+  case CURLUPART_HOST:
+    ptr = u->host;
+    ifmissing = CURLUE_NO_HOST;
+    break;
   case CURLUPART_ZONEID:
     ptr = u->zoneid;
     break;
-  case CURLUPART_PORT: 
-    ptr = u->port; 
-    ifmissing = CURLUE_NO_PORT; 
-    urldecode = FALSE; /* never for port */ 
-    if(!ptr && (flags & CURLU_DEFAULT_PORT) && u->scheme) { 
-      /* there's no stored port number, but asked to deliver 
-         a default one for the scheme */ 
-      const struct Curl_handler *h = 
-        Curl_builtin_scheme(u->scheme); 
-      if(h) { 
-        msnprintf(portbuf, sizeof(portbuf), "%ld", h->defport); 
-        ptr = portbuf; 
-      } 
-    } 
-    else if(ptr && u->scheme) { 
-      /* there is a stored port number, but ask to inhibit if 
-         it matches the default one for the scheme */ 
-      const struct Curl_handler *h = 
-        Curl_builtin_scheme(u->scheme); 
-      if(h && (h->defport == u->portnum) && 
-         (flags & CURLU_NO_DEFAULT_PORT)) 
-        ptr = NULL; 
-    } 
-    break; 
-  case CURLUPART_PATH: 
-    ptr = u->path; 
-    if(!ptr) { 
-      ptr = u->path = strdup("/"); 
-      if(!u->path) 
-        return CURLUE_OUT_OF_MEMORY; 
-    } 
-    break; 
-  case CURLUPART_QUERY: 
-    ptr = u->query; 
-    ifmissing = CURLUE_NO_QUERY; 
-    plusdecode = urldecode; 
-    break; 
-  case CURLUPART_FRAGMENT: 
-    ptr = u->fragment; 
-    ifmissing = CURLUE_NO_FRAGMENT; 
-    break; 
-  case CURLUPART_URL: { 
-    char *url; 
-    char *scheme; 
-    char *options = u->options; 
-    char *port = u->port; 
+  case CURLUPART_PORT:
+    ptr = u->port;
+    ifmissing = CURLUE_NO_PORT;
+    urldecode = FALSE; /* never for port */
+    if(!ptr && (flags & CURLU_DEFAULT_PORT) && u->scheme) {
+      /* there's no stored port number, but asked to deliver
+         a default one for the scheme */
+      const struct Curl_handler *h =
+        Curl_builtin_scheme(u->scheme);
+      if(h) {
+        msnprintf(portbuf, sizeof(portbuf), "%ld", h->defport);
+        ptr = portbuf;
+      }
+    }
+    else if(ptr && u->scheme) {
+      /* there is a stored port number, but ask to inhibit if
+         it matches the default one for the scheme */
+      const struct Curl_handler *h =
+        Curl_builtin_scheme(u->scheme);
+      if(h && (h->defport == u->portnum) &&
+         (flags & CURLU_NO_DEFAULT_PORT))
+        ptr = NULL;
+    }
+    break;
+  case CURLUPART_PATH:
+    ptr = u->path;
+    if(!ptr) {
+      ptr = u->path = strdup("/");
+      if(!u->path)
+        return CURLUE_OUT_OF_MEMORY;
+    }
+    break;
+  case CURLUPART_QUERY:
+    ptr = u->query;
+    ifmissing = CURLUE_NO_QUERY;
+    plusdecode = urldecode;
+    break;
+  case CURLUPART_FRAGMENT:
+    ptr = u->fragment;
+    ifmissing = CURLUE_NO_FRAGMENT;
+    break;
+  case CURLUPART_URL: {
+    char *url;
+    char *scheme;
+    char *options = u->options;
+    char *port = u->port;
     char *allochost = NULL;
-    if(u->scheme && strcasecompare("file", u->scheme)) { 
-      url = aprintf("file://%s%s%s", 
-                    u->path, 
-                    u->fragment? "#": "", 
-                    u->fragment? u->fragment : ""); 
-    } 
-    else if(!u->host) 
-      return CURLUE_NO_HOST; 
-    else { 
-      const struct Curl_handler *h = NULL; 
-      if(u->scheme) 
-        scheme = u->scheme; 
-      else if(flags & CURLU_DEFAULT_SCHEME) 
-        scheme = (char *) DEFAULT_SCHEME; 
-      else 
-        return CURLUE_NO_SCHEME; 
- 
+    if(u->scheme && strcasecompare("file", u->scheme)) {
+      url = aprintf("file://%s%s%s",
+                    u->path,
+                    u->fragment? "#": "",
+                    u->fragment? u->fragment : "");
+    }
+    else if(!u->host)
+      return CURLUE_NO_HOST;
+    else {
+      const struct Curl_handler *h = NULL;
+      if(u->scheme)
+        scheme = u->scheme;
+      else if(flags & CURLU_DEFAULT_SCHEME)
+        scheme = (char *) DEFAULT_SCHEME;
+      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
@@ -1122,8 +1122,8 @@ CURLUcode curl_url_get(CURLU *u, CURLUPart what,
         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 */
@@ -1132,9 +1132,9 @@ CURLUcode curl_url_get(CURLU *u, CURLUPart what,
           port = NULL;
       }
 
-      if(h && !(h->flags & PROTOPT_URLOPTIONS)) 
-        options = NULL; 
- 
+      if(h && !(h->flags & PROTOPT_URLOPTIONS))
+        options = NULL;
+
       if((u->host[0] == '[') && u->zoneid) {
         /* make it '[ host %25 zoneid ]' */
         size_t hostlen = strlen(u->host);
@@ -1147,318 +1147,318 @@ CURLUcode curl_url_get(CURLU *u, CURLUPart what,
                   "%%25%s]", u->zoneid);
       }
 
-      url = aprintf("%s://%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s", 
-                    scheme, 
-                    u->user ? u->user : "", 
-                    u->password ? ":": "", 
-                    u->password ? u->password : "", 
-                    options ? ";" : "", 
-                    options ? options : "", 
-                    (u->user || u->password || options) ? "@": "", 
+      url = aprintf("%s://%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
+                    scheme,
+                    u->user ? u->user : "",
+                    u->password ? ":": "",
+                    u->password ? u->password : "",
+                    options ? ";" : "",
+                    options ? options : "",
+                    (u->user || u->password || options) ? "@": "",
                     allochost ? allochost : u->host,
-                    port ? ":": "", 
-                    port ? port : "", 
-                    (u->path && (u->path[0] != '/')) ? "/": "", 
-                    u->path ? u->path : "/", 
+                    port ? ":": "",
+                    port ? port : "",
+                    (u->path && (u->path[0] != '/')) ? "/": "",
+                    u->path ? u->path : "/",
                     (u->query && u->query[0]) ? "?": "",
                     (u->query && u->query[0]) ? u->query : "",
-                    u->fragment? "#": "", 
-                    u->fragment? u->fragment : ""); 
+                    u->fragment? "#": "",
+                    u->fragment? u->fragment : "");
       free(allochost);
-    } 
-    if(!url) 
-      return CURLUE_OUT_OF_MEMORY; 
-    *part = url; 
-    return CURLUE_OK; 
-  } 
-  default: 
-    ptr = NULL; 
+    }
+    if(!url)
+      return CURLUE_OUT_OF_MEMORY;
+    *part = url;
+    return CURLUE_OK;
+  }
+  default:
+    ptr = NULL;
     break;
-  } 
-  if(ptr) { 
-    *part = strdup(ptr); 
-    if(!*part) 
-      return CURLUE_OUT_OF_MEMORY; 
-    if(plusdecode) { 
-      /* convert + to space */ 
-      char *plus; 
-      for(plus = *part; *plus; ++plus) { 
-        if(*plus == '+') 
-          *plus = ' '; 
-      } 
-    } 
-    if(urldecode) { 
-      char *decoded; 
-      size_t dlen; 
+  }
+  if(ptr) {
+    *part = strdup(ptr);
+    if(!*part)
+      return CURLUE_OUT_OF_MEMORY;
+    if(plusdecode) {
+      /* convert + to space */
+      char *plus;
+      for(plus = *part; *plus; ++plus) {
+        if(*plus == '+')
+          *plus = ' ';
+      }
+    }
+    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);
-      free(*part); 
-      if(res) { 
-        *part = NULL; 
-        return CURLUE_URLDECODE; 
-      } 
-      *part = decoded; 
-    } 
-    return CURLUE_OK; 
-  } 
-  else 
-    return ifmissing; 
-} 
- 
-CURLUcode curl_url_set(CURLU *u, CURLUPart what, 
-                       const char *part, unsigned int flags) 
-{ 
-  char **storep = NULL; 
-  long port = 0; 
-  bool urlencode = (flags & CURLU_URLENCODE)? 1 : 0; 
-  bool plusencode = FALSE; 
-  bool urlskipslash = FALSE; 
-  bool appendquery = FALSE; 
-  bool equalsencode = FALSE; 
- 
-  if(!u) 
-    return CURLUE_BAD_HANDLE; 
-  if(!part) { 
-    /* setting a part to NULL clears it */ 
-    switch(what) { 
-    case CURLUPART_URL: 
-      break; 
-    case CURLUPART_SCHEME: 
-      storep = &u->scheme; 
-      break; 
-    case CURLUPART_USER: 
-      storep = &u->user; 
-      break; 
-    case CURLUPART_PASSWORD: 
-      storep = &u->password; 
-      break; 
-    case CURLUPART_OPTIONS: 
-      storep = &u->options; 
-      break; 
-    case CURLUPART_HOST: 
-      storep = &u->host; 
-      break; 
+      free(*part);
+      if(res) {
+        *part = NULL;
+        return CURLUE_URLDECODE;
+      }
+      *part = decoded;
+    }
+    return CURLUE_OK;
+  }
+  else
+    return ifmissing;
+}
+
+CURLUcode curl_url_set(CURLU *u, CURLUPart what,
+                       const char *part, unsigned int flags)
+{
+  char **storep = NULL;
+  long port = 0;
+  bool urlencode = (flags & CURLU_URLENCODE)? 1 : 0;
+  bool plusencode = FALSE;
+  bool urlskipslash = FALSE;
+  bool appendquery = FALSE;
+  bool equalsencode = FALSE;
+
+  if(!u)
+    return CURLUE_BAD_HANDLE;
+  if(!part) {
+    /* setting a part to NULL clears it */
+    switch(what) {
+    case CURLUPART_URL:
+      break;
+    case CURLUPART_SCHEME:
+      storep = &u->scheme;
+      break;
+    case CURLUPART_USER:
+      storep = &u->user;
+      break;
+    case CURLUPART_PASSWORD:
+      storep = &u->password;
+      break;
+    case CURLUPART_OPTIONS:
+      storep = &u->options;
+      break;
+    case CURLUPART_HOST:
+      storep = &u->host;
+      break;
     case CURLUPART_ZONEID:
       storep = &u->zoneid;
       break;
-    case CURLUPART_PORT: 
+    case CURLUPART_PORT:
       u->portnum = 0;
-      storep = &u->port; 
-      break; 
-    case CURLUPART_PATH: 
-      storep = &u->path; 
-      break; 
-    case CURLUPART_QUERY: 
-      storep = &u->query; 
-      break; 
-    case CURLUPART_FRAGMENT: 
-      storep = &u->fragment; 
-      break; 
-    default: 
-      return CURLUE_UNKNOWN_PART; 
-    } 
-    if(storep && *storep) { 
+      storep = &u->port;
+      break;
+    case CURLUPART_PATH:
+      storep = &u->path;
+      break;
+    case CURLUPART_QUERY:
+      storep = &u->query;
+      break;
+    case CURLUPART_FRAGMENT:
+      storep = &u->fragment;
+      break;
+    default:
+      return CURLUE_UNKNOWN_PART;
+    }
+    if(storep && *storep) {
       Curl_safefree(*storep);
-    } 
-    return CURLUE_OK; 
-  } 
- 
-  switch(what) { 
-  case CURLUPART_SCHEME: 
+    }
+    return CURLUE_OK;
+  }
+
+  switch(what) {
+  case CURLUPART_SCHEME:
     if(strlen(part) > MAX_SCHEME_LEN)
       /* too long */
       return CURLUE_MALFORMED_INPUT;
-    if(!(flags & CURLU_NON_SUPPORT_SCHEME) && 
-       /* verify that it is a fine scheme */ 
-       !Curl_builtin_scheme(part)) 
-      return CURLUE_UNSUPPORTED_SCHEME; 
-    storep = &u->scheme; 
-    urlencode = FALSE; /* never */ 
-    break; 
-  case CURLUPART_USER: 
-    storep = &u->user; 
-    break; 
-  case CURLUPART_PASSWORD: 
-    storep = &u->password; 
-    break; 
-  case CURLUPART_OPTIONS: 
-    storep = &u->options; 
-    break; 
-  case CURLUPART_HOST: 
-    storep = &u->host; 
+    if(!(flags & CURLU_NON_SUPPORT_SCHEME) &&
+       /* verify that it is a fine scheme */
+       !Curl_builtin_scheme(part))
+      return CURLUE_UNSUPPORTED_SCHEME;
+    storep = &u->scheme;
+    urlencode = FALSE; /* never */
+    break;
+  case CURLUPART_USER:
+    storep = &u->user;
+    break;
+  case CURLUPART_PASSWORD:
+    storep = &u->password;
+    break;
+  case CURLUPART_OPTIONS:
+    storep = &u->options;
+    break;
+  case CURLUPART_HOST:
+    storep = &u->host;
     Curl_safefree(u->zoneid);
-    break; 
+    break;
   case CURLUPART_ZONEID:
     storep = &u->zoneid;
     break;
-  case CURLUPART_PORT: 
+  case CURLUPART_PORT:
   {
     char *endp;
-    urlencode = FALSE; /* never */ 
+    urlencode = FALSE; /* never */
     port = strtol(part, &endp, 10);  /* Port number must be decimal */
-    if((port <= 0) || (port > 0xffff)) 
-      return CURLUE_BAD_PORT_NUMBER; 
+    if((port <= 0) || (port > 0xffff))
+      return CURLUE_BAD_PORT_NUMBER;
     if(*endp)
       /* weirdly provided number, not good! */
       return CURLUE_MALFORMED_INPUT;
-    storep = &u->port; 
+    storep = &u->port;
   }
   break;
-  case CURLUPART_PATH: 
-    urlskipslash = TRUE; 
-    storep = &u->path; 
-    break; 
-  case CURLUPART_QUERY: 
-    plusencode = urlencode; 
-    appendquery = (flags & CURLU_APPENDQUERY)?1:0; 
-    equalsencode = appendquery; 
-    storep = &u->query; 
-    break; 
-  case CURLUPART_FRAGMENT: 
-    storep = &u->fragment; 
-    break; 
-  case CURLUPART_URL: { 
-    /* 
-     * Allow a new URL to replace the existing (if any) contents. 
-     * 
-     * If the existing contents is enough for a URL, allow a relative URL to 
-     * replace it. 
-     */ 
-    CURLUcode result; 
-    char *oldurl; 
-    char *redired_url; 
-    CURLU *handle2; 
- 
+  case CURLUPART_PATH:
+    urlskipslash = TRUE;
+    storep = &u->path;
+    break;
+  case CURLUPART_QUERY:
+    plusencode = urlencode;
+    appendquery = (flags & CURLU_APPENDQUERY)?1:0;
+    equalsencode = appendquery;
+    storep = &u->query;
+    break;
+  case CURLUPART_FRAGMENT:
+    storep = &u->fragment;
+    break;
+  case CURLUPART_URL: {
+    /*
+     * Allow a new URL to replace the existing (if any) contents.
+     *
+     * If the existing contents is enough for a URL, allow a relative URL to
+     * replace it.
+     */
+    CURLUcode result;
+    char *oldurl;
+    char *redired_url;
+    CURLU *handle2;
+
     if(Curl_is_absolute_url(part, NULL, MAX_SCHEME_LEN + 1)) {
-      handle2 = curl_url(); 
-      if(!handle2) 
-        return CURLUE_OUT_OF_MEMORY; 
-      result = parseurl(part, handle2, flags); 
-      if(!result) 
-        mv_urlhandle(handle2, u); 
-      else 
-        curl_url_cleanup(handle2); 
-      return result; 
-    } 
-    /* extract the full "old" URL to do the redirect on */ 
-    result = curl_url_get(u, CURLUPART_URL, &oldurl, flags); 
-    if(result) { 
-      /* couldn't get the old URL, just use the new! */ 
-      handle2 = curl_url(); 
-      if(!handle2) 
-        return CURLUE_OUT_OF_MEMORY; 
-      result = parseurl(part, handle2, flags); 
-      if(!result) 
-        mv_urlhandle(handle2, u); 
-      else 
-        curl_url_cleanup(handle2); 
-      return result; 
-    } 
- 
-    /* apply the relative part to create a new URL */ 
+      handle2 = curl_url();
+      if(!handle2)
+        return CURLUE_OUT_OF_MEMORY;
+      result = parseurl(part, handle2, flags);
+      if(!result)
+        mv_urlhandle(handle2, u);
+      else
+        curl_url_cleanup(handle2);
+      return result;
+    }
+    /* extract the full "old" URL to do the redirect on */
+    result = curl_url_get(u, CURLUPART_URL, &oldurl, flags);
+    if(result) {
+      /* couldn't get the old URL, just use the new! */
+      handle2 = curl_url();
+      if(!handle2)
+        return CURLUE_OUT_OF_MEMORY;
+      result = parseurl(part, handle2, flags);
+      if(!result)
+        mv_urlhandle(handle2, u);
+      else
+        curl_url_cleanup(handle2);
+      return result;
+    }
+
+    /* apply the relative part to create a new URL */
     redired_url = concat_url(oldurl, part);
-    free(oldurl); 
-    if(!redired_url) 
-      return CURLUE_OUT_OF_MEMORY; 
- 
-    /* now parse the new URL */ 
-    handle2 = curl_url(); 
-    if(!handle2) { 
-      free(redired_url); 
-      return CURLUE_OUT_OF_MEMORY; 
-    } 
-    result = parseurl(redired_url, handle2, flags); 
-    free(redired_url); 
-    if(!result) 
-      mv_urlhandle(handle2, u); 
-    else 
-      curl_url_cleanup(handle2); 
-    return result; 
-  } 
-  default: 
-    return CURLUE_UNKNOWN_PART; 
-  } 
+    free(oldurl);
+    if(!redired_url)
+      return CURLUE_OUT_OF_MEMORY;
+
+    /* now parse the new URL */
+    handle2 = curl_url();
+    if(!handle2) {
+      free(redired_url);
+      return CURLUE_OUT_OF_MEMORY;
+    }
+    result = parseurl(redired_url, handle2, flags);
+    free(redired_url);
+    if(!result)
+      mv_urlhandle(handle2, u);
+    else
+      curl_url_cleanup(handle2);
+    return result;
+  }
+  default:
+    return CURLUE_UNKNOWN_PART;
+  }
   DEBUGASSERT(storep);
   {
-    const char *newp = part; 
-    size_t nalloc = strlen(part); 
- 
+    const char *newp = part;
+    size_t nalloc = strlen(part);
+
     if(nalloc > CURL_MAX_INPUT_LENGTH)
       /* excessive input length */
       return CURLUE_MALFORMED_INPUT;
 
-    if(urlencode) { 
+    if(urlencode) {
       const unsigned char *i;
-      char *o; 
-      char *enc = malloc(nalloc * 3 + 1); /* for worst case! */ 
-      if(!enc) 
-        return CURLUE_OUT_OF_MEMORY; 
+      char *o;
+      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++;
-        } 
+        }
         else if(Curl_isunreserved(*i) ||
                 ((*i == '/') && urlskipslash) ||
                 ((*i == '=') && equalsencode)) {
-          if((*i == '=') && equalsencode) 
-            /* only skip the first equals sign */ 
-            equalsencode = FALSE; 
-          *o = *i; 
-          o++; 
-        } 
-        else { 
-          msnprintf(o, 4, "%%%02x", *i); 
-          o += 3; 
-        } 
-      } 
+          if((*i == '=') && equalsencode)
+            /* only skip the first equals sign */
+            equalsencode = FALSE;
+          *o = *i;
+          o++;
+        }
+        else {
+          msnprintf(o, 4, "%%%02x", *i);
+          o += 3;
+        }
+      }
       *o = 0; /* null-terminate */
-      newp = enc; 
-    } 
-    else { 
-      char *p; 
-      newp = strdup(part); 
-      if(!newp) 
-        return CURLUE_OUT_OF_MEMORY; 
-      p = (char *)newp; 
-      while(*p) { 
-        /* make sure percent encoded are lower case */ 
-        if((*p == '%') && ISXDIGIT(p[1]) && ISXDIGIT(p[2]) && 
-           (ISUPPER(p[1]) || ISUPPER(p[2]))) { 
-          p[1] = (char)TOLOWER(p[1]); 
-          p[2] = (char)TOLOWER(p[2]); 
-          p += 3; 
-        } 
-        else 
-          p++; 
-      } 
-    } 
- 
-    if(appendquery) { 
-      /* Append the string onto the old query. Add a '&' separator if none is 
-         present at the end of the exsting query already */ 
-      size_t querylen = u->query ? strlen(u->query) : 0; 
-      bool addamperand = querylen && (u->query[querylen -1] != '&'); 
-      if(querylen) { 
-        size_t newplen = strlen(newp); 
-        char *p = malloc(querylen + addamperand + newplen + 1); 
-        if(!p) { 
-          free((char *)newp); 
-          return CURLUE_OUT_OF_MEMORY; 
-        } 
-        strcpy(p, u->query); /* original query */ 
-        if(addamperand) 
-          p[querylen] = '&'; /* ampersand */ 
-        strcpy(&p[querylen + addamperand], newp); /* new suffix */ 
-        free((char *)newp); 
-        free(*storep); 
-        *storep = p; 
-        return CURLUE_OK; 
-      } 
-    } 
- 
+      newp = enc;
+    }
+    else {
+      char *p;
+      newp = strdup(part);
+      if(!newp)
+        return CURLUE_OUT_OF_MEMORY;
+      p = (char *)newp;
+      while(*p) {
+        /* make sure percent encoded are lower case */
+        if((*p == '%') && ISXDIGIT(p[1]) && ISXDIGIT(p[2]) &&
+           (ISUPPER(p[1]) || ISUPPER(p[2]))) {
+          p[1] = (char)TOLOWER(p[1]);
+          p[2] = (char)TOLOWER(p[2]);
+          p += 3;
+        }
+        else
+          p++;
+      }
+    }
+
+    if(appendquery) {
+      /* Append the string onto the old query. Add a '&' separator if none is
+         present at the end of the exsting query already */
+      size_t querylen = u->query ? strlen(u->query) : 0;
+      bool addamperand = querylen && (u->query[querylen -1] != '&');
+      if(querylen) {
+        size_t newplen = strlen(newp);
+        char *p = malloc(querylen + addamperand + newplen + 1);
+        if(!p) {
+          free((char *)newp);
+          return CURLUE_OUT_OF_MEMORY;
+        }
+        strcpy(p, u->query); /* original query */
+        if(addamperand)
+          p[querylen] = '&'; /* ampersand */
+        strcpy(&p[querylen + addamperand], newp); /* new suffix */
+        free((char *)newp);
+        free(*storep);
+        *storep = p;
+        return CURLUE_OK;
+      }
+    }
+
     if(what == CURLUPART_HOST) {
       if(0 == strlen(newp) && (flags & CURLU_NO_AUTHORITY)) {
         /* Skip hostname check, it's allowed to be empty. */
@@ -1471,12 +1471,12 @@ CURLUcode curl_url_set(CURLU *u, CURLUPart what,
       }
     }
 
-    free(*storep); 
-    *storep = (char *)newp; 
-  } 
-  /* set after the string, to make it not assigned if the allocation above 
-     fails */ 
-  if(port) 
-    u->portnum = port; 
-  return CURLUE_OK; 
-} 
+    free(*storep);
+    *storep = (char *)newp;
+  }
+  /* set after the string, to make it not assigned if the allocation above
+     fails */
+  if(port)
+    u->portnum = port;
+  return CURLUE_OK;
+}