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

1 files changed, 435 insertions, 435 deletions

diff --git a/contrib/libs/curl/lib/http.c b/contrib/libs/curl/lib/http.c
index c232ed4134..9db4499040 100644
--- a/contrib/libs/curl/lib/http.c
+++ b/contrib/libs/curl/lib/http.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
@@ -77,7 +77,7 @@
 #include "connect.h"
 #include "strdup.h"
 #include "altsvc.h"
-#include "hsts.h"
+#include "hsts.h" 
 
 /* The last 3 #include files should be in this order */
 #include "curl_printf.h"
@@ -126,9 +126,9 @@ const struct Curl_handler Curl_handler_http = {
   ZERO_NULL,                            /* connection_check */
   PORT_HTTP,                            /* defport */
   CURLPROTO_HTTP,                       /* protocol */
-  CURLPROTO_HTTP,                       /* family */
-  PROTOPT_CREDSPERREQUEST |             /* flags */
-  PROTOPT_USERPWDCTRL
+  CURLPROTO_HTTP,                       /* family */ 
+  PROTOPT_CREDSPERREQUEST |             /* flags */ 
+  PROTOPT_USERPWDCTRL 
 };
 
 #ifdef USE_SSL
@@ -153,9 +153,9 @@ const struct Curl_handler Curl_handler_https = {
   ZERO_NULL,                            /* connection_check */
   PORT_HTTPS,                           /* defport */
   CURLPROTO_HTTPS,                      /* protocol */
-  CURLPROTO_HTTP,                       /* family */
-  PROTOPT_SSL | PROTOPT_CREDSPERREQUEST | PROTOPT_ALPN_NPN | /* flags */
-  PROTOPT_USERPWDCTRL
+  CURLPROTO_HTTP,                       /* family */ 
+  PROTOPT_SSL | PROTOPT_CREDSPERREQUEST | PROTOPT_ALPN_NPN | /* flags */ 
+  PROTOPT_USERPWDCTRL 
 };
 #endif
 
@@ -165,14 +165,14 @@ static CURLcode http_setup_conn(struct connectdata *conn)
      during this request */
   struct HTTP *http;
   struct Curl_easy *data = conn->data;
-  DEBUGASSERT(data->req.p.http == NULL);
+  DEBUGASSERT(data->req.p.http == NULL); 
 
   http = calloc(1, sizeof(struct HTTP));
   if(!http)
     return CURLE_OUT_OF_MEMORY;
 
   Curl_mime_initpart(&http->form, conn->data);
-  data->req.p.http = http;
+  data->req.p.http = http; 
 
   if(data->set.httpversion == CURL_HTTP_VERSION_3) {
     if(conn->handler->flags & PROTOPT_SSL)
@@ -273,7 +273,7 @@ char *Curl_copy_header_value(const char *header)
     return NULL;
 
   memcpy(value, start, len);
-  value[len] = 0; /* null-terminate */
+  value[len] = 0; /* null-terminate */ 
 
   return value;
 }
@@ -297,21 +297,21 @@ static CURLcode http_output_basic(struct connectdata *conn, bool proxy)
   char *out;
 
   if(proxy) {
-#ifndef CURL_DISABLE_PROXY
-    userp = &data->state.aptr.proxyuserpwd;
+#ifndef CURL_DISABLE_PROXY 
+    userp = &data->state.aptr.proxyuserpwd; 
     user = conn->http_proxy.user;
     pwd = conn->http_proxy.passwd;
-#else
-    return CURLE_NOT_BUILT_IN;
-#endif
+#else 
+    return CURLE_NOT_BUILT_IN; 
+#endif 
   }
   else {
-    userp = &data->state.aptr.userpwd;
+    userp = &data->state.aptr.userpwd; 
     user = conn->user;
     pwd = conn->passwd;
   }
 
-  out = aprintf("%s:%s", user, pwd ? pwd : "");
+  out = aprintf("%s:%s", user, pwd ? pwd : ""); 
   if(!out)
     return CURLE_OUT_OF_MEMORY;
 
@@ -349,12 +349,12 @@ static CURLcode http_output_bearer(struct connectdata *conn)
 {
   char **userp;
   CURLcode result = CURLE_OK;
-  struct Curl_easy *data = conn->data;
+  struct Curl_easy *data = conn->data; 
 
-  userp = &data->state.aptr.userpwd;
+  userp = &data->state.aptr.userpwd; 
   free(*userp);
   *userp = aprintf("Authorization: Bearer %s\r\n",
-                   conn->data->set.str[STRING_BEARER]);
+                   conn->data->set.str[STRING_BEARER]); 
 
   if(!*userp) {
     result = CURLE_OUT_OF_MEMORY;
@@ -428,7 +428,7 @@ static bool pickoneauth(struct auth *pick, unsigned long mask)
 static CURLcode http_perhapsrewind(struct connectdata *conn)
 {
   struct Curl_easy *data = conn->data;
-  struct HTTP *http = data->req.p.http;
+  struct HTTP *http = data->req.p.http; 
   curl_off_t bytessent;
   curl_off_t expectsend = -1; /* default is unknown */
 
@@ -437,7 +437,7 @@ static CURLcode http_perhapsrewind(struct connectdata *conn)
        skip this rewinding stuff */
     return CURLE_OK;
 
-  switch(data->state.httpreq) {
+  switch(data->state.httpreq) { 
   case HTTPREQ_GET:
   case HTTPREQ_HEAD:
     return CURLE_OK;
@@ -458,7 +458,7 @@ static CURLcode http_perhapsrewind(struct connectdata *conn)
   }
   else {
     /* figure out how much data we are expected to send */
-    switch(data->state.httpreq) {
+    switch(data->state.httpreq) { 
     case HTTPREQ_POST:
     case HTTPREQ_PUT:
       if(data->state.infilesize != -1)
@@ -565,7 +565,7 @@ CURLcode Curl_http_auth_act(struct connectdata *conn)
   CURLcode result = CURLE_OK;
   unsigned long authmask = ~0ul;
 
-  if(!data->set.str[STRING_BEARER])
+  if(!data->set.str[STRING_BEARER]) 
     authmask &= (unsigned long)~CURLAUTH_BEARER;
 
   if(100 <= data->req.httpcode && 199 >= data->req.httpcode)
@@ -575,7 +575,7 @@ CURLcode Curl_http_auth_act(struct connectdata *conn)
   if(data->state.authproblem)
     return data->set.http_fail_on_error?CURLE_HTTP_RETURNED_ERROR:CURLE_OK;
 
-  if((conn->bits.user_passwd || data->set.str[STRING_BEARER]) &&
+  if((conn->bits.user_passwd || data->set.str[STRING_BEARER]) && 
      ((data->req.httpcode == 401) ||
       (conn->bits.authneg && data->req.httpcode < 300))) {
     pickhost = pickoneauth(&data->state.authhost, authmask);
@@ -588,7 +588,7 @@ CURLcode Curl_http_auth_act(struct connectdata *conn)
       conn->data->set.httpversion = CURL_HTTP_VERSION_1_1;
     }
   }
-#ifndef CURL_DISABLE_PROXY
+#ifndef CURL_DISABLE_PROXY 
   if(conn->bits.proxy_user_passwd &&
      ((data->req.httpcode == 407) ||
       (conn->bits.authneg && data->req.httpcode < 300))) {
@@ -597,11 +597,11 @@ CURLcode Curl_http_auth_act(struct connectdata *conn)
     if(!pickproxy)
       data->state.authproblem = TRUE;
   }
-#endif
+#endif 
 
   if(pickhost || pickproxy) {
-    if((data->state.httpreq != HTTPREQ_GET) &&
-       (data->state.httpreq != HTTPREQ_HEAD) &&
+    if((data->state.httpreq != HTTPREQ_GET) && 
+       (data->state.httpreq != HTTPREQ_HEAD) && 
        !conn->bits.rewindaftersend) {
       result = http_perhapsrewind(conn);
       if(result)
@@ -622,8 +622,8 @@ CURLcode Curl_http_auth_act(struct connectdata *conn)
        authentication is not "done" yet and
        no authentication seems to be required and
        we didn't try HEAD or GET */
-    if((data->state.httpreq != HTTPREQ_GET) &&
-       (data->state.httpreq != HTTPREQ_HEAD)) {
+    if((data->state.httpreq != HTTPREQ_GET) && 
+       (data->state.httpreq != HTTPREQ_HEAD)) { 
       data->req.newurl = strdup(data->change.url); /* clone URL */
       if(!data->req.newurl)
         return CURLE_OUT_OF_MEMORY;
@@ -701,13 +701,13 @@ output_auth_headers(struct connectdata *conn,
 #endif
   if(authstatus->picked == CURLAUTH_BASIC) {
     /* Basic */
-    if(
-#ifndef CURL_DISABLE_PROXY
-      (proxy && conn->bits.proxy_user_passwd &&
-       !Curl_checkProxyheaders(conn, "Proxy-authorization")) ||
-#endif
-      (!proxy && conn->bits.user_passwd &&
-       !Curl_checkheaders(conn, "Authorization"))) {
+    if( 
+#ifndef CURL_DISABLE_PROXY 
+      (proxy && conn->bits.proxy_user_passwd && 
+       !Curl_checkProxyheaders(conn, "Proxy-authorization")) || 
+#endif 
+      (!proxy && conn->bits.user_passwd && 
+       !Curl_checkheaders(conn, "Authorization"))) { 
       auth = "Basic";
       result = http_output_basic(conn, proxy);
       if(result)
@@ -720,7 +720,7 @@ output_auth_headers(struct connectdata *conn,
   }
   if(authstatus->picked == CURLAUTH_BEARER) {
     /* Bearer */
-    if((!proxy && data->set.str[STRING_BEARER] &&
+    if((!proxy && data->set.str[STRING_BEARER] && 
         !Curl_checkheaders(conn, "Authorization:"))) {
       auth = "Bearer";
       result = http_output_bearer(conn);
@@ -734,15 +734,15 @@ output_auth_headers(struct connectdata *conn,
   }
 
   if(auth) {
-#ifndef CURL_DISABLE_PROXY
+#ifndef CURL_DISABLE_PROXY 
     infof(data, "%s auth using %s with user '%s'\n",
           proxy ? "Proxy" : "Server", auth,
           proxy ? (conn->http_proxy.user ? conn->http_proxy.user : "") :
-          (conn->user ? conn->user : ""));
-#else
-    infof(data, "Server auth using %s with user '%s'\n",
-          auth, conn->user ? conn->user : "");
-#endif
+          (conn->user ? conn->user : "")); 
+#else 
+    infof(data, "Server auth using %s with user '%s'\n", 
+          auth, conn->user ? conn->user : ""); 
+#endif 
     authstatus->multipass = (!authstatus->done) ? TRUE : FALSE;
   }
   else
@@ -782,11 +782,11 @@ Curl_http_output_auth(struct connectdata *conn,
   authhost = &data->state.authhost;
   authproxy = &data->state.authproxy;
 
-  if(
-#ifndef CURL_DISABLE_PROXY
-    (conn->bits.httpproxy && conn->bits.proxy_user_passwd) ||
-#endif
-     conn->bits.user_passwd || data->set.str[STRING_BEARER])
+  if( 
+#ifndef CURL_DISABLE_PROXY 
+    (conn->bits.httpproxy && conn->bits.proxy_user_passwd) || 
+#endif 
+     conn->bits.user_passwd || data->set.str[STRING_BEARER]) 
     /* continue please */;
   else {
     authhost->done = TRUE;
@@ -1090,10 +1090,10 @@ static int http_should_fail(struct connectdata *conn)
   */
   if((httpcode == 401) && !conn->bits.user_passwd)
     return TRUE;
-#ifndef CURL_DISABLE_PROXY
+#ifndef CURL_DISABLE_PROXY 
   if((httpcode == 407) && !conn->bits.proxy_user_passwd)
     return TRUE;
-#endif
+#endif 
 
   return data->state.authproblem;
 }
@@ -1112,7 +1112,7 @@ static size_t readmoredata(char *buffer,
                            void *userp)
 {
   struct connectdata *conn = (struct connectdata *)userp;
-  struct HTTP *http = conn->data->req.p.http;
+  struct HTTP *http = conn->data->req.p.http; 
   size_t fullsize = size * nitems;
 
   if(!http->postsize)
@@ -1151,26 +1151,26 @@ static size_t readmoredata(char *buffer,
 }
 
 /*
- * Curl_buffer_send() sends a header buffer and frees all associated
+ * Curl_buffer_send() sends a header buffer and frees all associated 
  * memory.  Body data may be appended to the header data if desired.
  *
  * Returns CURLcode
  */
-CURLcode Curl_buffer_send(struct dynbuf *in,
-                          struct connectdata *conn,
-                          /* add the number of sent bytes to this
-                             counter */
-                          curl_off_t *bytes_written,
-                          /* how much of the buffer contains body data */
-                          size_t included_body_bytes,
-                          int socketindex)
+CURLcode Curl_buffer_send(struct dynbuf *in, 
+                          struct connectdata *conn, 
+                          /* add the number of sent bytes to this 
+                             counter */ 
+                          curl_off_t *bytes_written, 
+                          /* how much of the buffer contains body data */ 
+                          size_t included_body_bytes, 
+                          int socketindex) 
 {
   ssize_t amount;
   CURLcode result;
   char *ptr;
   size_t size;
   struct Curl_easy *data = conn->data;
-  struct HTTP *http = data->req.p.http;
+  struct HTTP *http = data->req.p.http; 
   size_t sendsize;
   curl_socket_t sockfd;
   size_t headersize;
@@ -1182,8 +1182,8 @@ CURLcode Curl_buffer_send(struct dynbuf *in,
   /* The looping below is required since we use non-blocking sockets, but due
      to the circumstances we will just loop and try again and again etc */
 
-  ptr = Curl_dyn_ptr(in);
-  size = Curl_dyn_len(in);
+  ptr = Curl_dyn_ptr(in); 
+  size = Curl_dyn_len(in); 
 
   headersize = size - included_body_bytes; /* the initial part that isn't body
                                               is header */
@@ -1194,15 +1194,15 @@ CURLcode Curl_buffer_send(struct dynbuf *in,
   /* Curl_convert_to_network calls failf if unsuccessful */
   if(result) {
     /* conversion failed, free memory and return to the caller */
-    Curl_dyn_free(in);
+    Curl_dyn_free(in); 
     return result;
   }
 
-  if((conn->handler->flags & PROTOPT_SSL
-#ifndef CURL_DISABLE_PROXY
-      || conn->http_proxy.proxytype == CURLPROXY_HTTPS
-#endif
-       )
+  if((conn->handler->flags & PROTOPT_SSL 
+#ifndef CURL_DISABLE_PROXY 
+      || conn->http_proxy.proxytype == CURLPROXY_HTTPS 
+#endif 
+       ) 
      && conn->httpversion != 20) {
     /* We never send more than CURL_MAX_WRITE_SIZE bytes in one single chunk
        when we speak HTTPS, as if only a fraction of it is sent now, this data
@@ -1221,27 +1221,27 @@ CURLcode Curl_buffer_send(struct dynbuf *in,
     result = Curl_get_upload_buffer(data);
     if(result) {
       /* malloc failed, free memory and return to the caller */
-      Curl_dyn_free(in);
+      Curl_dyn_free(in); 
       return result;
     }
     memcpy(data->state.ulbuf, ptr, sendsize);
     ptr = data->state.ulbuf;
   }
-  else {
-#ifdef CURLDEBUG
-    /* Allow debug builds override this logic to force short initial sends */
-    char *p = getenv("CURL_SMALLREQSEND");
-    if(p) {
-      size_t altsize = (size_t)strtoul(p, NULL, 10);
-      if(altsize)
-        sendsize = CURLMIN(size, altsize);
-      else
-        sendsize = size;
-    }
-    else
-#endif
+  else { 
+#ifdef CURLDEBUG 
+    /* Allow debug builds override this logic to force short initial sends */ 
+    char *p = getenv("CURL_SMALLREQSEND"); 
+    if(p) { 
+      size_t altsize = (size_t)strtoul(p, NULL, 10); 
+      if(altsize) 
+        sendsize = CURLMIN(size, altsize); 
+      else 
+        sendsize = size; 
+    } 
+    else 
+#endif 
     sendsize = size;
-  }
+  } 
 
   result = Curl_write(conn, sockfd, ptr, sendsize, &amount);
 
@@ -1255,12 +1255,12 @@ CURLcode Curl_buffer_send(struct dynbuf *in,
     size_t headlen = (size_t)amount>headersize ? headersize : (size_t)amount;
     size_t bodylen = amount - headlen;
 
-    /* this data _may_ contain binary stuff */
-    Curl_debug(data, CURLINFO_HEADER_OUT, ptr, headlen);
-    if(bodylen)
-      /* there was body data sent beyond the initial header part, pass that on
-         to the debug callback too */
-      Curl_debug(data, CURLINFO_DATA_OUT, ptr + headlen, bodylen);
+    /* this data _may_ contain binary stuff */ 
+    Curl_debug(data, CURLINFO_HEADER_OUT, ptr, headlen); 
+    if(bodylen) 
+      /* there was body data sent beyond the initial header part, pass that on 
+         to the debug callback too */ 
+      Curl_debug(data, CURLINFO_DATA_OUT, ptr + headlen, bodylen); 
 
     /* 'amount' can never be a very large value here so typecasting it so a
        signed 31 bit value should not cause problems even if ssize_t is
@@ -1280,7 +1280,7 @@ CURLcode Curl_buffer_send(struct dynbuf *in,
 
         size -= amount;
 
-        ptr = Curl_dyn_ptr(in) + amount;
+        ptr = Curl_dyn_ptr(in) + amount; 
 
         /* backup the currently set pointers */
         http->backup.fread_func = data->state.fread_func;
@@ -1294,7 +1294,7 @@ CURLcode Curl_buffer_send(struct dynbuf *in,
         http->postdata = ptr;
         http->postsize = (curl_off_t)size;
 
-        http->send_buffer = *in; /* copy the whole struct */
+        http->send_buffer = *in; /* copy the whole struct */ 
         http->sending = HTTPSEND_REQUEST;
 
         return CURLE_OK;
@@ -1314,7 +1314,7 @@ CURLcode Curl_buffer_send(struct dynbuf *in,
         return CURLE_SEND_ERROR;
     }
   }
-  Curl_dyn_free(in);
+  Curl_dyn_free(in); 
 
   return result;
 }
@@ -1352,7 +1352,7 @@ Curl_compareheader(const char *headerline, /* line to check */
   /* pass the header */
   start = &headerline[hlen];
 
-  /* pass all whitespace */
+  /* pass all whitespace */ 
   while(*start && ISSPACE(*start))
     start++;
 
@@ -1391,7 +1391,7 @@ CURLcode Curl_http_connect(struct connectdata *conn, bool *done)
      function to make the re-use checks properly be able to check this bit. */
   connkeep(conn, "HTTP default");
 
-#ifndef CURL_DISABLE_PROXY
+#ifndef CURL_DISABLE_PROXY 
   /* the CONNECT procedure might not have been completed */
   result = Curl_proxy_connect(conn, FIRSTSOCKET);
   if(result)
@@ -1443,7 +1443,7 @@ static int http_getsock_do(struct connectdata *conn,
 static CURLcode add_haproxy_protocol_header(struct connectdata *conn)
 {
   char proxy_header[128];
-  struct dynbuf req;
+  struct dynbuf req; 
   CURLcode result;
   char tcp_version[5];
 
@@ -1464,14 +1464,14 @@ static CURLcode add_haproxy_protocol_header(struct connectdata *conn)
             conn->data->info.conn_local_port,
             conn->data->info.conn_primary_port);
 
-  Curl_dyn_init(&req, DYN_HAXPROXY);
+  Curl_dyn_init(&req, DYN_HAXPROXY); 
 
-  result = Curl_dyn_add(&req, proxy_header);
+  result = Curl_dyn_add(&req, proxy_header); 
   if(result)
     return result;
 
-  result = Curl_buffer_send(&req, conn, &conn->data->info.request_size,
-                            0, FIRSTSOCKET);
+  result = Curl_buffer_send(&req, conn, &conn->data->info.request_size, 
+                            0, FIRSTSOCKET); 
 
   return result;
 }
@@ -1516,7 +1516,7 @@ CURLcode Curl_http_done(struct connectdata *conn,
                         CURLcode status, bool premature)
 {
   struct Curl_easy *data = conn->data;
-  struct HTTP *http = data->req.p.http;
+  struct HTTP *http = data->req.p.http; 
 
   /* Clear multipass flag. If authentication isn't done yet, then it will get
    * a chance to be set back to true when we output the next auth header */
@@ -1532,11 +1532,11 @@ CURLcode Curl_http_done(struct connectdata *conn,
   if(!http)
     return CURLE_OK;
 
-  Curl_dyn_free(&http->send_buffer);
-  Curl_http2_done(data, premature);
-  Curl_quic_done(data, premature);
+  Curl_dyn_free(&http->send_buffer); 
+  Curl_http2_done(data, premature); 
+  Curl_quic_done(data, premature); 
   Curl_mime_cleanpart(&http->form);
-  Curl_dyn_reset(&data->state.headerb);
+  Curl_dyn_reset(&data->state.headerb); 
 
   if(status)
     return status;
@@ -1602,12 +1602,12 @@ static const char *get_http_string(const struct Curl_easy *data,
 /* check and possibly add an Expect: header */
 static CURLcode expect100(struct Curl_easy *data,
                           struct connectdata *conn,
-                          struct dynbuf *req)
+                          struct dynbuf *req) 
 {
   CURLcode result = CURLE_OK;
   data->state.expect100header = FALSE; /* default to false unless it is set
                                           to TRUE below */
-  if(!data->state.disableexpect && use_http_1_1plus(data, conn) &&
+  if(!data->state.disableexpect && use_http_1_1plus(data, conn) && 
      (conn->httpversion < 20)) {
     /* if not doing HTTP 1.0 or version 2, or disabled explicitly, we add an
        Expect: 100-continue to the headers which actually speeds up post
@@ -1618,7 +1618,7 @@ static CURLcode expect100(struct Curl_easy *data,
         Curl_compareheader(ptr, "Expect:", "100-continue");
     }
     else {
-      result = Curl_dyn_add(req, "Expect: 100-continue\r\n");
+      result = Curl_dyn_add(req, "Expect: 100-continue\r\n"); 
       if(!result)
         data->state.expect100header = TRUE;
     }
@@ -1637,7 +1637,7 @@ enum proxy_use {
    will return an error code if one of the headers is
    not formatted correctly */
 CURLcode Curl_http_compile_trailers(struct curl_slist *trailers,
-                                    struct dynbuf *b,
+                                    struct dynbuf *b, 
                                     struct Curl_easy *handle)
 {
   char *ptr = NULL;
@@ -1663,24 +1663,24 @@ CURLcode Curl_http_compile_trailers(struct curl_slist *trailers,
     /* only add correctly formatted trailers */
     ptr = strchr(trailers->data, ':');
     if(ptr && *(ptr + 1) == ' ') {
-      result = Curl_dyn_add(b, trailers->data);
-      if(result)
-        return result;
-      result = Curl_dyn_add(b, endofline_native);
+      result = Curl_dyn_add(b, trailers->data); 
       if(result)
         return result;
+      result = Curl_dyn_add(b, endofline_native); 
+      if(result) 
+        return result; 
     }
     else
       infof(handle, "Malformatted trailing header ! Skipping trailer.");
     trailers = trailers->next;
   }
-  result = Curl_dyn_add(b, endofline_network);
+  result = Curl_dyn_add(b, endofline_network); 
   return result;
 }
 
 CURLcode Curl_add_custom_headers(struct connectdata *conn,
                                  bool is_connect,
-                                 struct dynbuf *req)
+                                 struct dynbuf *req) 
 {
   char *ptr;
   struct curl_slist *h[2];
@@ -1689,7 +1689,7 @@ CURLcode Curl_add_custom_headers(struct connectdata *conn,
   struct Curl_easy *data = conn->data;
   int i;
 
-#ifndef CURL_DISABLE_PROXY
+#ifndef CURL_DISABLE_PROXY 
   enum proxy_use proxy;
 
   if(is_connect)
@@ -1716,10 +1716,10 @@ CURLcode Curl_add_custom_headers(struct connectdata *conn,
       h[0] = data->set.headers;
     break;
   }
-#else
-  (void)is_connect;
-  h[0] = data->set.headers;
-#endif
+#else 
+  (void)is_connect; 
+  h[0] = data->set.headers; 
+#endif 
 
   /* loop through one or two lists */
   for(i = 0; i < numlists; i++) {
@@ -1747,7 +1747,7 @@ CURLcode Curl_add_custom_headers(struct connectdata *conn,
               /* copy the source */
               semicolonp = strdup(headers->data);
               if(!semicolonp) {
-                Curl_dyn_free(req);
+                Curl_dyn_free(req); 
                 return CURLE_OUT_OF_MEMORY;
               }
               /* put a colon where the semicolon is */
@@ -1771,16 +1771,16 @@ CURLcode Curl_add_custom_headers(struct connectdata *conn,
           CURLcode result = CURLE_OK;
           char *compare = semicolonp ? semicolonp : headers->data;
 
-          if(data->state.aptr.host &&
+          if(data->state.aptr.host && 
              /* a Host: header was sent already, don't pass on any custom Host:
                 header as that will produce *two* in the same request! */
              checkprefix("Host:", compare))
             ;
-          else if(data->state.httpreq == HTTPREQ_POST_FORM &&
+          else if(data->state.httpreq == HTTPREQ_POST_FORM && 
                   /* this header (extended by formdata.c) is sent later */
                   checkprefix("Content-Type:", compare))
             ;
-          else if(data->state.httpreq == HTTPREQ_POST_MIME &&
+          else if(data->state.httpreq == HTTPREQ_POST_MIME && 
                   /* this header is sent later */
                   checkprefix("Content-Type:", compare))
             ;
@@ -1789,7 +1789,7 @@ CURLcode Curl_add_custom_headers(struct connectdata *conn,
                      we will force length zero then */
                   checkprefix("Content-Length:", compare))
             ;
-          else if(data->state.aptr.te &&
+          else if(data->state.aptr.te && 
                   /* when asking for Transfer-Encoding, don't pass on a custom
                      Connection: */
                   checkprefix("Connection:", compare))
@@ -1808,7 +1808,7 @@ CURLcode Curl_add_custom_headers(struct connectdata *conn,
                    !strcasecompare(data->state.first_host, conn->host.name)))
             ;
           else {
-            result = Curl_dyn_addf(req, "%s\r\n", compare);
+            result = Curl_dyn_addf(req, "%s\r\n", compare); 
           }
           if(semicolonp)
             free(semicolonp);
@@ -1825,7 +1825,7 @@ CURLcode Curl_add_custom_headers(struct connectdata *conn,
 
 #ifndef CURL_DISABLE_PARSEDATE
 CURLcode Curl_add_timecondition(const struct connectdata *conn,
-                                struct dynbuf *req)
+                                struct dynbuf *req) 
 {
   struct Curl_easy *data = conn->data;
   const struct tm *tm;
@@ -1884,17 +1884,17 @@ CURLcode Curl_add_timecondition(const struct connectdata *conn,
             tm->tm_min,
             tm->tm_sec);
 
-  result = Curl_dyn_add(req, datestr);
+  result = Curl_dyn_add(req, datestr); 
 
   return result;
 }
 #else
 /* disabled */
 CURLcode Curl_add_timecondition(const struct connectdata *conn,
-                                struct dynbuf *req)
+                                struct dynbuf *req) 
 {
   (void)conn;
-  (void)req;
+  (void)req; 
   return CURLE_OK;
 }
 #endif
@@ -1917,13 +1917,13 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
   const char *te = ""; /* transfer-encoding */
   const char *ptr;
   const char *request;
-  Curl_HttpReq httpreq = data->state.httpreq;
+  Curl_HttpReq httpreq = data->state.httpreq; 
 #if !defined(CURL_DISABLE_COOKIES)
   char *addcookies = NULL;
 #endif
   curl_off_t included_body = 0;
   const char *httpstring;
-  struct dynbuf req;
+  struct dynbuf req; 
   curl_off_t postsize = 0; /* curl_off_t to handle large file sizes */
   char *altused = NULL;
 
@@ -1951,14 +1951,14 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
 #ifdef USE_NGHTTP2
         if(conn->data->set.httpversion ==
            CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE) {
-#ifndef CURL_DISABLE_PROXY
+#ifndef CURL_DISABLE_PROXY 
           if(conn->bits.httpproxy && !conn->bits.tunnel_proxy) {
             /* We don't support HTTP/2 proxies yet. Also it's debatable
                whether or not this setting should apply to HTTP/2 proxies. */
             infof(data, "Ignoring HTTP/2 prior knowledge due to proxy\n");
             break;
           }
-#endif
+#endif 
           DEBUGF(infof(data, "HTTP/2 over clean TCP\n"));
           conn->httpversion = 20;
 
@@ -1977,7 +1977,7 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
         return result;
     }
   }
-  http = data->req.p.http;
+  http = data->req.p.http; 
   DEBUGASSERT(http);
 
   if(!data->state.this_is_a_follow) {
@@ -2029,8 +2029,8 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
      with the user-agent string specified, we erase the previously made string
      here. */
   if(Curl_checkheaders(conn, "User-Agent")) {
-    free(data->state.aptr.uagent);
-    data->state.aptr.uagent = NULL;
+    free(data->state.aptr.uagent); 
+    data->state.aptr.uagent = NULL; 
   }
 
   /* setup the authentication headers */
@@ -2058,14 +2058,14 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
   else
     conn->bits.authneg = FALSE;
 
-  Curl_safefree(data->state.aptr.ref);
+  Curl_safefree(data->state.aptr.ref); 
   if(data->change.referer && !Curl_checkheaders(conn, "Referer")) {
-    data->state.aptr.ref = aprintf("Referer: %s\r\n", data->change.referer);
-    if(!data->state.aptr.ref)
+    data->state.aptr.ref = aprintf("Referer: %s\r\n", data->change.referer); 
+    if(!data->state.aptr.ref) 
       return CURLE_OUT_OF_MEMORY;
   }
   else
-    data->state.aptr.ref = NULL;
+    data->state.aptr.ref = NULL; 
 
 #if !defined(CURL_DISABLE_COOKIES)
   if(data->set.str[STRING_COOKIE] && !Curl_checkheaders(conn, "Cookie"))
@@ -2074,15 +2074,15 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
 
   if(!Curl_checkheaders(conn, "Accept-Encoding") &&
      data->set.str[STRING_ENCODING]) {
-    Curl_safefree(data->state.aptr.accept_encoding);
-    data->state.aptr.accept_encoding =
+    Curl_safefree(data->state.aptr.accept_encoding); 
+    data->state.aptr.accept_encoding = 
       aprintf("Accept-Encoding: %s\r\n", data->set.str[STRING_ENCODING]);
-    if(!data->state.aptr.accept_encoding)
+    if(!data->state.aptr.accept_encoding) 
       return CURLE_OUT_OF_MEMORY;
   }
   else {
-    Curl_safefree(data->state.aptr.accept_encoding);
-    data->state.aptr.accept_encoding = NULL;
+    Curl_safefree(data->state.aptr.accept_encoding); 
+    data->state.aptr.accept_encoding = NULL; 
   }
 
 #ifdef HAVE_LIBZ
@@ -2098,7 +2098,7 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
     char *cptr = Curl_checkheaders(conn, "Connection");
 #define TE_HEADER "TE: gzip\r\n"
 
-    Curl_safefree(data->state.aptr.te);
+    Curl_safefree(data->state.aptr.te); 
 
     if(cptr) {
       cptr = Curl_copy_header_value(cptr);
@@ -2107,11 +2107,11 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
     }
 
     /* Create the (updated) Connection: header */
-    data->state.aptr.te = aprintf("Connection: %s%sTE\r\n" TE_HEADER,
+    data->state.aptr.te = aprintf("Connection: %s%sTE\r\n" TE_HEADER, 
                                 cptr ? cptr : "", (cptr && *cptr) ? ", ":"");
 
     free(cptr);
-    if(!data->state.aptr.te)
+    if(!data->state.aptr.te) 
       return CURLE_OUT_OF_MEMORY;
   }
 #endif
@@ -2194,7 +2194,7 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
       te = "Transfer-Encoding: chunked\r\n";
   }
 
-  Curl_safefree(data->state.aptr.host);
+  Curl_safefree(data->state.aptr.host); 
 
   ptr = Curl_checkheaders(conn, "Host");
   if(ptr && (!data->state.this_is_a_follow ||
@@ -2229,19 +2229,19 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
         if(colon)
           *colon = 0; /* The host must not include an embedded port number */
       }
-      Curl_safefree(data->state.aptr.cookiehost);
-      data->state.aptr.cookiehost = cookiehost;
+      Curl_safefree(data->state.aptr.cookiehost); 
+      data->state.aptr.cookiehost = cookiehost; 
     }
 #endif
 
     if(strcmp("Host:", ptr)) {
-      data->state.aptr.host = aprintf("Host:%s\r\n", &ptr[5]);
-      if(!data->state.aptr.host)
+      data->state.aptr.host = aprintf("Host:%s\r\n", &ptr[5]); 
+      if(!data->state.aptr.host) 
         return CURLE_OUT_OF_MEMORY;
     }
     else
       /* when clearing the header */
-      data->state.aptr.host = NULL;
+      data->state.aptr.host = NULL; 
   }
   else {
     /* When building Host: headers, we must put the host name within
@@ -2253,18 +2253,18 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
         (conn->remote_port == PORT_HTTP)) )
       /* if(HTTPS on port 443) OR (HTTP on port 80) then don't include
          the port number in the host string */
-      data->state.aptr.host = aprintf("Host: %s%s%s\r\n",
+      data->state.aptr.host = aprintf("Host: %s%s%s\r\n", 
                                     conn->bits.ipv6_ip?"[":"",
                                     host,
                                     conn->bits.ipv6_ip?"]":"");
     else
-      data->state.aptr.host = aprintf("Host: %s%s%s:%d\r\n",
+      data->state.aptr.host = aprintf("Host: %s%s%s:%d\r\n", 
                                     conn->bits.ipv6_ip?"[":"",
                                     host,
                                     conn->bits.ipv6_ip?"]":"",
                                     conn->remote_port);
 
-    if(!data->state.aptr.host)
+    if(!data->state.aptr.host) 
       /* without Host: we can't make a nice request */
       return CURLE_OUT_OF_MEMORY;
   }
@@ -2309,7 +2309,7 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
         return CURLE_OUT_OF_MEMORY;
       }
     }
-    /* Extract the URL to use in the request. Store in STRING_TEMP_URL for
+    /* Extract the URL to use in the request. Store in STRING_TEMP_URL for 
        clean-up reasons if the function returns before the free() further
        down. */
     uc = curl_url_get(h, CURLUPART_URL, &data->set.str[STRING_TEMP_URL], 0);
@@ -2345,7 +2345,7 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
                     data->set.prefer_ascii ? 'a' : 'i');
         }
       }
-      if(conn->bits.user_passwd)
+      if(conn->bits.user_passwd) 
         paste_ftp_userpwd = TRUE;
     }
   }
@@ -2435,21 +2435,21 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
     if(((httpreq == HTTPREQ_GET) || (httpreq == HTTPREQ_HEAD)) &&
        !Curl_checkheaders(conn, "Range")) {
       /* if a line like this was already allocated, free the previous one */
-      free(data->state.aptr.rangeline);
-      data->state.aptr.rangeline = aprintf("Range: bytes=%s\r\n",
+      free(data->state.aptr.rangeline); 
+      data->state.aptr.rangeline = aprintf("Range: bytes=%s\r\n", 
                                          data->state.range);
     }
     else if((httpreq == HTTPREQ_POST || httpreq == HTTPREQ_PUT) &&
             !Curl_checkheaders(conn, "Content-Range")) {
 
       /* if a line like this was already allocated, free the previous one */
-      free(data->state.aptr.rangeline);
+      free(data->state.aptr.rangeline); 
 
       if(data->set.set_resume_from < 0) {
         /* Upload resume was asked for, but we don't know the size of the
            remote part so we tell the server (and act accordingly) that we
            upload the whole file (again) */
-        data->state.aptr.rangeline =
+        data->state.aptr.rangeline = 
           aprintf("Content-Range: bytes 0-%" CURL_FORMAT_CURL_OFF_T
                   "/%" CURL_FORMAT_CURL_OFF_T "\r\n",
                   data->state.infilesize - 1, data->state.infilesize);
@@ -2459,7 +2459,7 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
         /* This is because "resume" was selected */
         curl_off_t total_expected_size =
           data->state.resume_from + data->state.infilesize;
-        data->state.aptr.rangeline =
+        data->state.aptr.rangeline = 
           aprintf("Content-Range: bytes %s%" CURL_FORMAT_CURL_OFF_T
                   "/%" CURL_FORMAT_CURL_OFF_T "\r\n",
                   data->state.range, total_expected_size-1,
@@ -2468,11 +2468,11 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
       else {
         /* Range was selected and then we just pass the incoming range and
            append total size */
-        data->state.aptr.rangeline =
+        data->state.aptr.rangeline = 
           aprintf("Content-Range: bytes %s/%" CURL_FORMAT_CURL_OFF_T "\r\n",
                   data->state.range, data->state.infilesize);
       }
-      if(!data->state.aptr.rangeline)
+      if(!data->state.aptr.rangeline) 
         return CURLE_OUT_OF_MEMORY;
     }
   }
@@ -2480,11 +2480,11 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
   httpstring = get_http_string(data, conn);
 
   /* initialize a dynamic send-buffer */
-  Curl_dyn_init(&req, DYN_HTTP_REQUEST);
+  Curl_dyn_init(&req, DYN_HTTP_REQUEST); 
 
   /* add the main request stuff */
   /* GET/HEAD/POST/PUT */
-  result = Curl_dyn_addf(&req, "%s ", request);
+  result = Curl_dyn_addf(&req, "%s ", request); 
   if(result)
     return result;
 
@@ -2497,87 +2497,87 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
   /* url */
   if(conn->bits.httpproxy && !conn->bits.tunnel_proxy) {
     char *url = data->set.str[STRING_TEMP_URL];
-    result = Curl_dyn_add(&req, url);
+    result = Curl_dyn_add(&req, url); 
     Curl_safefree(data->set.str[STRING_TEMP_URL]);
   }
   else
 #endif
   if(paste_ftp_userpwd)
-    result = Curl_dyn_addf(&req, "ftp://%s:%s@%s", conn->user, conn->passwd,
-                           path + sizeof("ftp://") - 1);
+    result = Curl_dyn_addf(&req, "ftp://%s:%s@%s", conn->user, conn->passwd, 
+                           path + sizeof("ftp://") - 1); 
   else {
-    result = Curl_dyn_add(&req, path);
+    result = Curl_dyn_add(&req, path); 
     if(result)
       return result;
     if(query)
-      result = Curl_dyn_addf(&req, "?%s", query);
+      result = Curl_dyn_addf(&req, "?%s", query); 
   }
   if(result)
     return result;
 
-#ifndef CURL_DISABLE_ALTSVC
+#ifndef CURL_DISABLE_ALTSVC 
   if(conn->bits.altused && !Curl_checkheaders(conn, "Alt-Used")) {
     altused = aprintf("Alt-Used: %s:%d\r\n",
                       conn->conn_to_host.name, conn->conn_to_port);
-    if(!altused) {
-      Curl_dyn_free(&req);
+    if(!altused) { 
+      Curl_dyn_free(&req); 
       return CURLE_OUT_OF_MEMORY;
-    }
+    } 
   }
 #endif
   result =
-    Curl_dyn_addf(&req,
-                  "%s" /* ftp typecode (;type=x) */
-                  " HTTP/%s\r\n" /* HTTP version */
-                  "%s" /* host */
-                  "%s" /* proxyuserpwd */
-                  "%s" /* userpwd */
-                  "%s" /* range */
-                  "%s" /* user agent */
-                  "%s" /* accept */
-                  "%s" /* TE: */
-                  "%s" /* accept-encoding */
-                  "%s" /* referer */
-                  "%s" /* Proxy-Connection */
-                  "%s" /* transfer-encoding */
-                  "%s",/* Alt-Used */
-
-                  ftp_typecode,
-                  httpstring,
-                  (data->state.aptr.host?data->state.aptr.host:""),
-                  data->state.aptr.proxyuserpwd?
-                  data->state.aptr.proxyuserpwd:"",
-                  data->state.aptr.userpwd?data->state.aptr.userpwd:"",
-                  (data->state.use_range && data->state.aptr.rangeline)?
-                  data->state.aptr.rangeline:"",
-                  (data->set.str[STRING_USERAGENT] &&
-                   *data->set.str[STRING_USERAGENT] &&
-                   data->state.aptr.uagent)?
-                  data->state.aptr.uagent:"",
-                  http->p_accept?http->p_accept:"",
-                  data->state.aptr.te?data->state.aptr.te:"",
-                  (data->set.str[STRING_ENCODING] &&
-                   *data->set.str[STRING_ENCODING] &&
-                   data->state.aptr.accept_encoding)?
-                  data->state.aptr.accept_encoding:"",
-                  (data->change.referer && data->state.aptr.ref)?
-                  data->state.aptr.ref:"" /* Referer: <data> */,
-#ifndef CURL_DISABLE_PROXY
-                  (conn->bits.httpproxy &&
-                   !conn->bits.tunnel_proxy &&
-                   !Curl_checkProxyheaders(conn, "Proxy-Connection"))?
-                  "Proxy-Connection: Keep-Alive\r\n":"",
-#else
-                  "",
-#endif
-                  te,
-                  altused ? altused : ""
+    Curl_dyn_addf(&req, 
+                  "%s" /* ftp typecode (;type=x) */ 
+                  " HTTP/%s\r\n" /* HTTP version */ 
+                  "%s" /* host */ 
+                  "%s" /* proxyuserpwd */ 
+                  "%s" /* userpwd */ 
+                  "%s" /* range */ 
+                  "%s" /* user agent */ 
+                  "%s" /* accept */ 
+                  "%s" /* TE: */ 
+                  "%s" /* accept-encoding */ 
+                  "%s" /* referer */ 
+                  "%s" /* Proxy-Connection */ 
+                  "%s" /* transfer-encoding */ 
+                  "%s",/* Alt-Used */ 
+
+                  ftp_typecode, 
+                  httpstring, 
+                  (data->state.aptr.host?data->state.aptr.host:""), 
+                  data->state.aptr.proxyuserpwd? 
+                  data->state.aptr.proxyuserpwd:"", 
+                  data->state.aptr.userpwd?data->state.aptr.userpwd:"", 
+                  (data->state.use_range && data->state.aptr.rangeline)? 
+                  data->state.aptr.rangeline:"", 
+                  (data->set.str[STRING_USERAGENT] && 
+                   *data->set.str[STRING_USERAGENT] && 
+                   data->state.aptr.uagent)? 
+                  data->state.aptr.uagent:"", 
+                  http->p_accept?http->p_accept:"", 
+                  data->state.aptr.te?data->state.aptr.te:"", 
+                  (data->set.str[STRING_ENCODING] && 
+                   *data->set.str[STRING_ENCODING] && 
+                   data->state.aptr.accept_encoding)? 
+                  data->state.aptr.accept_encoding:"", 
+                  (data->change.referer && data->state.aptr.ref)? 
+                  data->state.aptr.ref:"" /* Referer: <data> */, 
+#ifndef CURL_DISABLE_PROXY 
+                  (conn->bits.httpproxy && 
+                   !conn->bits.tunnel_proxy && 
+                   !Curl_checkProxyheaders(conn, "Proxy-Connection"))? 
+                  "Proxy-Connection: Keep-Alive\r\n":"", 
+#else 
+                  "", 
+#endif 
+                  te, 
+                  altused ? altused : "" 
       );
 
   /* clear userpwd and proxyuserpwd to avoid re-using old credentials
    * from re-used connections */
-  Curl_safefree(data->state.aptr.userpwd);
-  Curl_safefree(data->state.aptr.proxyuserpwd);
+  Curl_safefree(data->state.aptr.userpwd); 
+  Curl_safefree(data->state.aptr.proxyuserpwd); 
   free(altused);
 
   if(result)
@@ -2588,7 +2588,7 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
      (data->set.httpversion == CURL_HTTP_VERSION_2)) {
     /* append HTTP2 upgrade magic stuff to the HTTP request if it isn't done
        over SSL */
-    result = Curl_http2_request_upgrade(&req, conn);
+    result = Curl_http2_request_upgrade(&req, conn); 
     if(result)
       return result;
   }
@@ -2598,11 +2598,11 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
     struct Cookie *co = NULL; /* no cookies from start */
     int count = 0;
 
-    if(data->cookies && data->state.cookie_engine) {
+    if(data->cookies && data->state.cookie_engine) { 
       Curl_share_lock(data, CURL_LOCK_DATA_COOKIE, CURL_LOCK_ACCESS_SINGLE);
       co = Curl_cookie_getlist(data->cookies,
-                               data->state.aptr.cookiehost?
-                               data->state.aptr.cookiehost:host,
+                               data->state.aptr.cookiehost? 
+                               data->state.aptr.cookiehost:host, 
                                data->state.up.path,
                                (conn->handler->protocol&CURLPROTO_HTTPS)?
                                TRUE:FALSE);
@@ -2614,12 +2614,12 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
       while(co) {
         if(co->value) {
           if(0 == count) {
-            result = Curl_dyn_add(&req, "Cookie: ");
+            result = Curl_dyn_add(&req, "Cookie: "); 
             if(result)
               break;
           }
-          result = Curl_dyn_addf(&req, "%s%s=%s", count?"; ":"",
-                                 co->name, co->value);
+          result = Curl_dyn_addf(&req, "%s%s=%s", count?"; ":"", 
+                                 co->name, co->value); 
           if(result)
             break;
           count++;
@@ -2630,25 +2630,25 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
     }
     if(addcookies && !result) {
       if(!count)
-        result = Curl_dyn_add(&req, "Cookie: ");
+        result = Curl_dyn_add(&req, "Cookie: "); 
       if(!result) {
-        result = Curl_dyn_addf(&req, "%s%s", count?"; ":"", addcookies);
+        result = Curl_dyn_addf(&req, "%s%s", count?"; ":"", addcookies); 
         count++;
       }
     }
     if(count && !result)
-      result = Curl_dyn_add(&req, "\r\n");
+      result = Curl_dyn_add(&req, "\r\n"); 
 
     if(result)
       return result;
   }
 #endif
 
-  result = Curl_add_timecondition(conn, &req);
+  result = Curl_add_timecondition(conn, &req); 
   if(result)
     return result;
 
-  result = Curl_add_custom_headers(conn, FALSE, &req);
+  result = Curl_add_custom_headers(conn, FALSE, &req); 
   if(result)
     return result;
 
@@ -2671,20 +2671,20 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
     if((postsize != -1) && !data->req.upload_chunky &&
        (conn->bits.authneg || !Curl_checkheaders(conn, "Content-Length"))) {
       /* only add Content-Length if not uploading chunked */
-      result = Curl_dyn_addf(&req, "Content-Length: %" CURL_FORMAT_CURL_OFF_T
-                             "\r\n", postsize);
+      result = Curl_dyn_addf(&req, "Content-Length: %" CURL_FORMAT_CURL_OFF_T 
+                             "\r\n", postsize); 
       if(result)
         return result;
     }
 
     if(postsize != 0) {
-      result = expect100(data, conn, &req);
+      result = expect100(data, conn, &req); 
       if(result)
         return result;
     }
 
-    /* end of headers */
-    result = Curl_dyn_add(&req, "\r\n");
+    /* end of headers */ 
+    result = Curl_dyn_add(&req, "\r\n"); 
     if(result)
       return result;
 
@@ -2692,8 +2692,8 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
     Curl_pgrsSetUploadSize(data, postsize);
 
     /* this sends the buffer and frees all the buffer resources */
-    result = Curl_buffer_send(&req, conn, &data->info.request_size, 0,
-                              FIRSTSOCKET);
+    result = Curl_buffer_send(&req, conn, &data->info.request_size, 0, 
+                              FIRSTSOCKET); 
     if(result)
       failf(data, "Failed sending PUT request");
     else
@@ -2709,12 +2709,12 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
     /* This is form posting using mime data. */
     if(conn->bits.authneg) {
       /* nothing to post! */
-      result = Curl_dyn_add(&req, "Content-Length: 0\r\n\r\n");
+      result = Curl_dyn_add(&req, "Content-Length: 0\r\n\r\n"); 
       if(result)
         return result;
 
-      result = Curl_buffer_send(&req, conn, &data->info.request_size, 0,
-                                FIRSTSOCKET);
+      result = Curl_buffer_send(&req, conn, &data->info.request_size, 0, 
+                                FIRSTSOCKET); 
       if(result)
         failf(data, "Failed sending POST request");
       else
@@ -2732,9 +2732,9 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
        (conn->bits.authneg || !Curl_checkheaders(conn, "Content-Length"))) {
       /* we allow replacing this header if not during auth negotiation,
          although it isn't very wise to actually set your own */
-      result = Curl_dyn_addf(&req,
-                             "Content-Length: %" CURL_FORMAT_CURL_OFF_T
-                             "\r\n", postsize);
+      result = Curl_dyn_addf(&req, 
+                             "Content-Length: %" CURL_FORMAT_CURL_OFF_T 
+                             "\r\n", postsize); 
       if(result)
         return result;
     }
@@ -2745,7 +2745,7 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
       struct curl_slist *hdr;
 
       for(hdr = http->sendit->curlheaders; hdr; hdr = hdr->next) {
-        result = Curl_dyn_addf(&req, "%s\r\n", hdr->data);
+        result = Curl_dyn_addf(&req, "%s\r\n", hdr->data); 
         if(result)
           return result;
       }
@@ -2762,7 +2762,7 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
         Curl_compareheader(ptr, "Expect:", "100-continue");
     }
     else if(postsize > EXPECT_100_THRESHOLD || postsize < 0) {
-      result = expect100(data, conn, &req);
+      result = expect100(data, conn, &req); 
       if(result)
         return result;
     }
@@ -2770,7 +2770,7 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
       data->state.expect100header = FALSE;
 
     /* make the request end in a true CRLF */
-    result = Curl_dyn_add(&req, "\r\n");
+    result = Curl_dyn_add(&req, "\r\n"); 
     if(result)
       return result;
 
@@ -2783,8 +2783,8 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
     http->sending = HTTPSEND_BODY;
 
     /* this sends the buffer and frees all the buffer resources */
-    result = Curl_buffer_send(&req, conn, &data->info.request_size, 0,
-                              FIRSTSOCKET);
+    result = Curl_buffer_send(&req, conn, &data->info.request_size, 0, 
+                              FIRSTSOCKET); 
     if(result)
       failf(data, "Failed sending POST request");
     else
@@ -2812,15 +2812,15 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
        (conn->bits.authneg || !Curl_checkheaders(conn, "Content-Length"))) {
       /* we allow replacing this header if not during auth negotiation,
          although it isn't very wise to actually set your own */
-      result = Curl_dyn_addf(&req, "Content-Length: %" CURL_FORMAT_CURL_OFF_T
-                             "\r\n", postsize);
+      result = Curl_dyn_addf(&req, "Content-Length: %" CURL_FORMAT_CURL_OFF_T 
+                             "\r\n", postsize); 
       if(result)
         return result;
     }
 
     if(!Curl_checkheaders(conn, "Content-Type")) {
-      result = Curl_dyn_add(&req, "Content-Type: application/"
-                            "x-www-form-urlencoded\r\n");
+      result = Curl_dyn_add(&req, "Content-Type: application/" 
+                            "x-www-form-urlencoded\r\n"); 
       if(result)
         return result;
     }
@@ -2835,7 +2835,7 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
         Curl_compareheader(ptr, "Expect:", "100-continue");
     }
     else if(postsize > EXPECT_100_THRESHOLD || postsize < 0) {
-      result = expect100(data, conn, &req);
+      result = expect100(data, conn, &req); 
       if(result)
         return result;
     }
@@ -2856,38 +2856,38 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
            is no magic limit but only set to prevent really huge POSTs to
            get the data duplicated with malloc() and family. */
 
-        /* end of headers! */
-        result = Curl_dyn_add(&req, "\r\n");
+        /* end of headers! */ 
+        result = Curl_dyn_add(&req, "\r\n"); 
         if(result)
           return result;
 
         if(!data->req.upload_chunky) {
           /* We're not sending it 'chunked', append it to the request
              already now to reduce the number if send() calls */
-          result = Curl_dyn_addn(&req, data->set.postfields,
-                                 (size_t)postsize);
+          result = Curl_dyn_addn(&req, data->set.postfields, 
+                                 (size_t)postsize); 
           included_body = postsize;
         }
         else {
           if(postsize) {
-            char chunk[16];
+            char chunk[16]; 
             /* Append the POST data chunky-style */
-            msnprintf(chunk, sizeof(chunk), "%x\r\n", (int)postsize);
-            result = Curl_dyn_add(&req, chunk);
+            msnprintf(chunk, sizeof(chunk), "%x\r\n", (int)postsize); 
+            result = Curl_dyn_add(&req, chunk); 
             if(!result) {
-              included_body = postsize + strlen(chunk);
-              result = Curl_dyn_addn(&req, data->set.postfields,
-                                     (size_t)postsize);
+              included_body = postsize + strlen(chunk); 
+              result = Curl_dyn_addn(&req, data->set.postfields, 
+                                     (size_t)postsize); 
               if(!result)
-                result = Curl_dyn_add(&req, "\r\n");
-              included_body += 2;
+                result = Curl_dyn_add(&req, "\r\n"); 
+              included_body += 2; 
             }
           }
-          if(!result) {
-            result = Curl_dyn_add(&req, "\x30\x0d\x0a\x0d\x0a");
-            /* 0  CR  LF  CR  LF */
-            included_body += 5;
-          }
+          if(!result) { 
+            result = Curl_dyn_add(&req, "\x30\x0d\x0a\x0d\x0a"); 
+            /* 0  CR  LF  CR  LF */ 
+            included_body += 5; 
+          } 
         }
         if(result)
           return result;
@@ -2907,22 +2907,22 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
         /* set the upload size to the progress meter */
         Curl_pgrsSetUploadSize(data, http->postsize);
 
-        /* end of headers! */
-        result = Curl_dyn_add(&req, "\r\n");
+        /* end of headers! */ 
+        result = Curl_dyn_add(&req, "\r\n"); 
         if(result)
           return result;
       }
     }
     else {
-       /* end of headers! */
-      result = Curl_dyn_add(&req, "\r\n");
+       /* end of headers! */ 
+      result = Curl_dyn_add(&req, "\r\n"); 
       if(result)
         return result;
 
       if(data->req.upload_chunky && conn->bits.authneg) {
         /* Chunky upload is selected and we're negotiating auth still, send
            end-of-data only */
-        result = Curl_dyn_add(&req, (char *)"\x30\x0d\x0a\x0d\x0a");
+        result = Curl_dyn_add(&req, (char *)"\x30\x0d\x0a\x0d\x0a"); 
         /* 0  CR  LF  CR  LF */
         if(result)
           return result;
@@ -2942,8 +2942,8 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
       }
     }
     /* issue the request */
-    result = Curl_buffer_send(&req, conn, &data->info.request_size,
-                              (size_t)included_body, FIRSTSOCKET);
+    result = Curl_buffer_send(&req, conn, &data->info.request_size, 
+                              (size_t)included_body, FIRSTSOCKET); 
 
     if(result)
       failf(data, "Failed sending HTTP POST request");
@@ -2953,24 +2953,24 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
     break;
 
   default:
-    result = Curl_dyn_add(&req, "\r\n");
+    result = Curl_dyn_add(&req, "\r\n"); 
     if(result)
       return result;
 
     /* issue the request */
-    result = Curl_buffer_send(&req, conn, &data->info.request_size, 0,
-                              FIRSTSOCKET);
+    result = Curl_buffer_send(&req, conn, &data->info.request_size, 0, 
+                              FIRSTSOCKET); 
 
     if(result)
       failf(data, "Failed sending HTTP request");
     else
       /* HTTP GET/HEAD download: */
-      Curl_setup_transfer(data, FIRSTSOCKET, -1, TRUE, -1);
+      Curl_setup_transfer(data, FIRSTSOCKET, -1, TRUE, -1); 
   }
   if(result)
     return result;
-  if(!postsize && (http->sending != HTTPSEND_REQUEST))
-    data->req.upload_done = TRUE;
+  if(!postsize && (http->sending != HTTPSEND_REQUEST)) 
+    data->req.upload_done = TRUE; 
 
   if(data->req.writebytecount) {
     /* if a request-body has been sent off, we make sure this progress is noted
@@ -3107,7 +3107,7 @@ checkprotoprefix(struct Curl_easy *data, struct connectdata *conn,
 static void print_http_error(struct Curl_easy *data)
 {
   struct SingleRequest *k = &data->req;
-  char *beg = Curl_dyn_ptr(&data->state.headerb);
+  char *beg = Curl_dyn_ptr(&data->state.headerb); 
 
   /* make sure that data->req.p points to the HTTP status line */
   if(!strncmp(beg, "HTTP", 4)) {
@@ -3145,17 +3145,17 @@ static void print_http_error(struct Curl_easy *data)
  * Read any HTTP header lines from the server and pass them to the client app.
  */
 CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
-                                     struct connectdata *conn,
-                                     ssize_t *nread,
-                                     bool *stop_reading)
+                                     struct connectdata *conn, 
+                                     ssize_t *nread, 
+                                     bool *stop_reading) 
 {
   CURLcode result;
   struct SingleRequest *k = &data->req;
   ssize_t onread = *nread;
   char *ostr = k->str;
-  char *headp;
-  char *str_start;
-  char *end_ptr;
+  char *headp; 
+  char *str_start; 
+  char *end_ptr; 
 
   /* header line within buffer loop */
   do {
@@ -3164,25 +3164,25 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
     int writetype;
 
     /* str_start is start of line within buf */
-    str_start = k->str;
+    str_start = k->str; 
 
     /* data is in network encoding so use 0x0a instead of '\n' */
-    end_ptr = memchr(str_start, 0x0a, *nread);
+    end_ptr = memchr(str_start, 0x0a, *nread); 
 
-    if(!end_ptr) {
+    if(!end_ptr) { 
       /* Not a complete header line within buffer, append the data to
          the end of the headerbuff. */
-      result = Curl_dyn_addn(&data->state.headerb, str_start, *nread);
+      result = Curl_dyn_addn(&data->state.headerb, str_start, *nread); 
       if(result)
         return result;
 
       if(!k->headerline) {
         /* check if this looks like a protocol header */
-        statusline st =
-          checkprotoprefix(data, conn,
-                           Curl_dyn_ptr(&data->state.headerb),
-                           Curl_dyn_len(&data->state.headerb));
-
+        statusline st = 
+          checkprotoprefix(data, conn, 
+                           Curl_dyn_ptr(&data->state.headerb), 
+                           Curl_dyn_len(&data->state.headerb)); 
+ 
         if(st == STATUS_BAD) {
           /* this is not the beginning of a protocol first header line */
           k->header = FALSE;
@@ -3200,26 +3200,26 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
     }
 
     /* decrease the size of the remaining (supposed) header line */
-    rest_length = (end_ptr - k->str) + 1;
+    rest_length = (end_ptr - k->str) + 1; 
     *nread -= (ssize_t)rest_length;
 
-    k->str = end_ptr + 1; /* move past new line */
+    k->str = end_ptr + 1; /* move past new line */ 
 
-    full_length = k->str - str_start;
+    full_length = k->str - str_start; 
 
-    result = Curl_dyn_addn(&data->state.headerb, str_start, full_length);
+    result = Curl_dyn_addn(&data->state.headerb, str_start, full_length); 
     if(result)
       return result;
 
     /****
-     * We now have a FULL header line in 'headerb'.
+     * We now have a FULL header line in 'headerb'. 
      *****/
 
     if(!k->headerline) {
       /* the first read header */
-      statusline st = checkprotoprefix(data, conn,
-                                       Curl_dyn_ptr(&data->state.headerb),
-                                       Curl_dyn_len(&data->state.headerb));
+      statusline st = checkprotoprefix(data, conn, 
+                                       Curl_dyn_ptr(&data->state.headerb), 
+                                       Curl_dyn_len(&data->state.headerb)); 
       if(st == STATUS_BAD) {
         streamclose(conn, "bad HTTP: No end-of-message indicator");
         /* this is not the beginning of a protocol first header line */
@@ -3242,27 +3242,27 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
       }
     }
 
-    /* headers are in network encoding so use 0x0a and 0x0d instead of '\n'
-       and '\r' */
-    headp = Curl_dyn_ptr(&data->state.headerb);
-    if((0x0a == *headp) || (0x0d == *headp)) {
+    /* headers are in network encoding so use 0x0a and 0x0d instead of '\n' 
+       and '\r' */ 
+    headp = Curl_dyn_ptr(&data->state.headerb); 
+    if((0x0a == *headp) || (0x0d == *headp)) { 
       size_t headerlen;
       /* Zero-length header line means end of headers! */
 
 #ifdef CURL_DOES_CONVERSIONS
-      if(0x0d == *headp) {
-        *headp = '\r'; /* replace with CR in host encoding */
-        headp++;       /* pass the CR byte */
+      if(0x0d == *headp) { 
+        *headp = '\r'; /* replace with CR in host encoding */ 
+        headp++;       /* pass the CR byte */ 
       }
-      if(0x0a == *headp) {
-        *headp = '\n'; /* replace with LF in host encoding */
-        headp++;       /* pass the LF byte */
+      if(0x0a == *headp) { 
+        *headp = '\n'; /* replace with LF in host encoding */ 
+        headp++;       /* pass the LF byte */ 
       }
 #else
-      if('\r' == *headp)
-        headp++; /* pass the \r byte */
-      if('\n' == *headp)
-        headp++; /* pass the \n byte */
+      if('\r' == *headp) 
+        headp++; /* pass the \r byte */ 
+      if('\n' == *headp) 
+        headp++; /* pass the \n byte */ 
 #endif /* CURL_DOES_CONVERSIONS */
 
       if(100 <= k->httpcode && 199 >= k->httpcode) {
@@ -3323,7 +3323,7 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
         if((k->size == -1) && !k->chunk && !conn->bits.close &&
            (conn->httpversion == 11) &&
            !(conn->handler->protocol & CURLPROTO_RTSP) &&
-           data->state.httpreq != HTTPREQ_HEAD) {
+           data->state.httpreq != HTTPREQ_HEAD) { 
           /* On HTTP 1.1, when connection is not to get closed, but no
              Content-Length nor Transfer-Encoding chunked have been
              received, according to RFC2616 section 4.4 point 5, we
@@ -3381,9 +3381,9 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
       if(data->set.include_header)
         writetype |= CLIENTWRITE_BODY;
 
-      headerlen = Curl_dyn_len(&data->state.headerb);
+      headerlen = Curl_dyn_len(&data->state.headerb); 
       result = Curl_client_write(conn, writetype,
-                                 Curl_dyn_ptr(&data->state.headerb),
+                                 Curl_dyn_ptr(&data->state.headerb), 
                                  headerlen);
       if(result)
         return result;
@@ -3418,7 +3418,7 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
            * continue sending even if it gets discarded
            */
 
-          switch(data->state.httpreq) {
+          switch(data->state.httpreq) { 
           case HTTPREQ_PUT:
           case HTTPREQ_POST:
           case HTTPREQ_POST_FORM:
@@ -3429,16 +3429,16 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
              */
             Curl_expire_done(data, EXPIRE_100_TIMEOUT);
             if(!k->upload_done) {
-              if((k->httpcode == 417) && data->state.expect100header) {
-                /* 417 Expectation Failed - try again without the Expect
-                   header */
-                infof(data, "Got 417 while waiting for a 100\n");
-                data->state.disableexpect = TRUE;
-                DEBUGASSERT(!data->req.newurl);
-                data->req.newurl = strdup(conn->data->change.url);
-                Curl_done_sending(conn, k);
-              }
-              else if(data->set.http_keep_sending_on_error) {
+              if((k->httpcode == 417) && data->state.expect100header) { 
+                /* 417 Expectation Failed - try again without the Expect 
+                   header */ 
+                infof(data, "Got 417 while waiting for a 100\n"); 
+                data->state.disableexpect = TRUE; 
+                DEBUGASSERT(!data->req.newurl); 
+                data->req.newurl = strdup(conn->data->change.url); 
+                Curl_done_sending(conn, k); 
+              } 
+              else if(data->set.http_keep_sending_on_error) { 
                 infof(data, "HTTP error before end of send, keep sending\n");
                 if(k->exp100 > EXP100_SEND_DATA) {
                   k->exp100 = EXP100_SEND_DATA;
@@ -3534,12 +3534,12 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
           k->keepon &= ~KEEP_RECV;
         }
 
-        Curl_debug(data, CURLINFO_HEADER_IN, str_start, headerlen);
-        break; /* exit header line loop */
+        Curl_debug(data, CURLINFO_HEADER_IN, str_start, headerlen); 
+        break; /* exit header line loop */ 
       }
 
-      /* We continue reading headers, reset the line-based header */
-      Curl_dyn_reset(&data->state.headerb);
+      /* We continue reading headers, reset the line-based header */ 
+      Curl_dyn_reset(&data->state.headerb); 
       continue;
     }
 
@@ -3558,11 +3558,11 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
 #define SCRATCHSIZE 21
       CURLcode res;
       char scratch[SCRATCHSIZE + 1]; /* "HTTP/major.minor 123" */
-      /* We can't really convert this yet because we don't know if it's the
-         1st header line or the body.  So we do a partial conversion into a
-         scratch area, leaving the data at 'headp' as-is.
+      /* We can't really convert this yet because we don't know if it's the 
+         1st header line or the body.  So we do a partial conversion into a 
+         scratch area, leaving the data at 'headp' as-is. 
       */
-      strncpy(&scratch[0], headp, SCRATCHSIZE);
+      strncpy(&scratch[0], headp, SCRATCHSIZE); 
       scratch[SCRATCHSIZE] = 0; /* null terminate */
       res = Curl_convert_from_network(data,
                                       &scratch[0],
@@ -3571,7 +3571,7 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
         /* Curl_convert_from_network calls failf if unsuccessful */
         return res;
 #else
-#define HEADER1 headp /* no conversion needed, just use headp */
+#define HEADER1 headp /* no conversion needed, just use headp */ 
 #endif /* CURL_DOES_CONVERSIONS */
 
       if(conn->handler->protocol & PROTO_FAMILY_HTTP) {
@@ -3622,11 +3622,11 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
              compare header line against list of aliases
           */
           if(!nc) {
-            statusline check =
-              checkhttpprefix(data,
-                              Curl_dyn_ptr(&data->state.headerb),
-                              Curl_dyn_len(&data->state.headerb));
-            if(check == STATUS_DONE) {
+            statusline check = 
+              checkhttpprefix(data, 
+                              Curl_dyn_ptr(&data->state.headerb), 
+                              Curl_dyn_len(&data->state.headerb)); 
+            if(check == STATUS_DONE) { 
               nc = 1;
               k->httpcode = 200;
               conn->httpversion = 10;
@@ -3672,18 +3672,18 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
          * depending on how authentication is working.  Other codes
          * are definitely errors, so give up here.
          */
-        if(data->state.resume_from && data->state.httpreq == HTTPREQ_GET &&
+        if(data->state.resume_from && data->state.httpreq == HTTPREQ_GET && 
              k->httpcode == 416) {
           /* "Requested Range Not Satisfiable", just proceed and
              pretend this is no error */
           k->ignorebody = TRUE; /* Avoid appending error msg to good data. */
         }
         else if(data->set.http_fail_on_error && (k->httpcode >= 400) &&
-                ((k->httpcode != 401) || !conn->bits.user_passwd)
-#ifndef CURL_DISABLE_PROXY
-                && ((k->httpcode != 407) || !conn->bits.proxy_user_passwd)
-#endif
-          ) {
+                ((k->httpcode != 401) || !conn->bits.user_passwd) 
+#ifndef CURL_DISABLE_PROXY 
+                && ((k->httpcode != 407) || !conn->bits.proxy_user_passwd) 
+#endif 
+          ) { 
           /* serious error, go home! */
           print_http_error(data);
           return CURLE_HTTP_RETURNED_ERROR;
@@ -3699,8 +3699,8 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
         else if(conn->httpversion == 20 ||
                 (k->upgr101 == UPGR101_REQUESTED && k->httpcode == 101)) {
           DEBUGF(infof(data, "HTTP/2 found, allow multiplexing\n"));
-          /* HTTP/2 cannot avoid multiplexing since it is a core functionality
-             of the protocol */
+          /* HTTP/2 cannot avoid multiplexing since it is a core functionality 
+             of the protocol */ 
           conn->bundle->multiuse = BUNDLE_MULTIPLEX;
         }
         else if(conn->httpversion >= 11 &&
@@ -3740,16 +3740,16 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
       }
     }
 
-    result = Curl_convert_from_network(data, headp, strlen(headp));
+    result = Curl_convert_from_network(data, headp, strlen(headp)); 
     /* Curl_convert_from_network calls failf if unsuccessful */
     if(result)
       return result;
 
     /* Check for Content-Length: header lines to get size */
     if(!k->http_bodyless &&
-       !data->set.ignorecl && checkprefix("Content-Length:", headp)) {
+       !data->set.ignorecl && checkprefix("Content-Length:", headp)) { 
       curl_off_t contentlength;
-      CURLofft offt = curlx_strtoofft(headp + 15, NULL, 10, &contentlength);
+      CURLofft offt = curlx_strtoofft(headp + 15, NULL, 10, &contentlength); 
 
       if(offt == CURL_OFFT_OK) {
         if(data->set.max_filesize &&
@@ -3780,8 +3780,8 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
       }
     }
     /* check for Content-Type: header lines to get the MIME-type */
-    else if(checkprefix("Content-Type:", headp)) {
-      char *contenttype = Curl_copy_header_value(headp);
+    else if(checkprefix("Content-Type:", headp)) { 
+      char *contenttype = Curl_copy_header_value(headp); 
       if(!contenttype)
         return CURLE_OUT_OF_MEMORY;
       if(!*contenttype)
@@ -3792,10 +3792,10 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
         data->info.contenttype = contenttype;
       }
     }
-#ifndef CURL_DISABLE_PROXY
+#ifndef CURL_DISABLE_PROXY 
     else if((conn->httpversion == 10) &&
             conn->bits.httpproxy &&
-            Curl_compareheader(headp, "Proxy-Connection:", "keep-alive")) {
+            Curl_compareheader(headp, "Proxy-Connection:", "keep-alive")) { 
       /*
        * When a HTTP/1.0 reply comes when using a proxy, the
        * 'Proxy-Connection: keep-alive' line tells us the
@@ -3807,7 +3807,7 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
     }
     else if((conn->httpversion == 11) &&
             conn->bits.httpproxy &&
-            Curl_compareheader(headp, "Proxy-Connection:", "close")) {
+            Curl_compareheader(headp, "Proxy-Connection:", "close")) { 
       /*
        * We get a HTTP/1.1 response from a proxy and it says it'll
        * close down after this transfer.
@@ -3815,9 +3815,9 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
       connclose(conn, "Proxy-Connection: asked to close after done");
       infof(data, "HTTP/1.1 proxy connection set close!\n");
     }
-#endif
+#endif 
     else if((conn->httpversion == 10) &&
-            Curl_compareheader(headp, "Connection:", "keep-alive")) {
+            Curl_compareheader(headp, "Connection:", "keep-alive")) { 
       /*
        * A HTTP/1.0 reply with the 'Connection: keep-alive' line
        * tells us the connection will be kept alive for our
@@ -3827,7 +3827,7 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
       connkeep(conn, "Connection keep-alive");
       infof(data, "HTTP/1.0 connection set to keep alive!\n");
     }
-    else if(Curl_compareheader(headp, "Connection:", "close")) {
+    else if(Curl_compareheader(headp, "Connection:", "close")) { 
       /*
        * [RFC 2616, section 8.1.2.1]
        * "Connection: close" is HTTP/1.1 language and means that
@@ -3836,7 +3836,7 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
        */
       streamclose(conn, "Connection: close used");
     }
-    else if(!k->http_bodyless && checkprefix("Transfer-Encoding:", headp)) {
+    else if(!k->http_bodyless && checkprefix("Transfer-Encoding:", headp)) { 
       /* One or more encodings. We check for chunked and/or a compression
          algorithm. */
       /*
@@ -3848,11 +3848,11 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
        * of chunks, and a chunk-data set to zero signals the
        * end-of-chunks. */
 
-      result = Curl_build_unencoding_stack(conn, headp + 18, TRUE);
+      result = Curl_build_unencoding_stack(conn, headp + 18, TRUE); 
       if(result)
         return result;
     }
-    else if(!k->http_bodyless && checkprefix("Content-Encoding:", headp) &&
+    else if(!k->http_bodyless && checkprefix("Content-Encoding:", headp) && 
             data->set.str[STRING_ENCODING]) {
       /*
        * Process Content-Encoding. Look for the values: identity,
@@ -3861,24 +3861,24 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
        * 2616). zlib cannot handle compress.  However, errors are
        * handled further down when the response body is processed
        */
-      result = Curl_build_unencoding_stack(conn, headp + 17, FALSE);
+      result = Curl_build_unencoding_stack(conn, headp + 17, FALSE); 
       if(result)
         return result;
     }
-    else if(checkprefix("Retry-After:", headp)) {
+    else if(checkprefix("Retry-After:", headp)) { 
       /* Retry-After = HTTP-date / delay-seconds */
       curl_off_t retry_after = 0; /* zero for unknown or "now" */
-      time_t date = Curl_getdate_capped(&headp[12]);
+      time_t date = Curl_getdate_capped(&headp[12]); 
       if(-1 == date) {
         /* not a date, try it as a decimal number */
-        (void)curlx_strtoofft(&headp[12], NULL, 10, &retry_after);
+        (void)curlx_strtoofft(&headp[12], NULL, 10, &retry_after); 
       }
       else
         /* convert date to number of seconds into the future */
         retry_after = date - time(NULL);
       data->info.retry_after = retry_after; /* store it */
     }
-    else if(!k->http_bodyless && checkprefix("Content-Range:", headp)) {
+    else if(!k->http_bodyless && checkprefix("Content-Range:", headp)) { 
       /* Content-Range: bytes [num]-
          Content-Range: bytes: [num]-
          Content-Range: [num]-
@@ -3890,7 +3890,7 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
          The forth means the requested range was unsatisfied.
       */
 
-      char *ptr = headp + 14;
+      char *ptr = headp + 14; 
 
       /* Move forward until first digit or asterisk */
       while(*ptr && !ISDIGIT(*ptr) && *ptr != '*')
@@ -3908,35 +3908,35 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
         data->state.resume_from = 0; /* get everything */
     }
 #if !defined(CURL_DISABLE_COOKIES)
-    else if(data->cookies && data->state.cookie_engine &&
-            checkprefix("Set-Cookie:", headp)) {
+    else if(data->cookies && data->state.cookie_engine && 
+            checkprefix("Set-Cookie:", headp)) { 
       Curl_share_lock(data, CURL_LOCK_DATA_COOKIE,
                       CURL_LOCK_ACCESS_SINGLE);
       Curl_cookie_add(data,
-                      data->cookies, TRUE, FALSE, headp + 11,
+                      data->cookies, TRUE, FALSE, headp + 11, 
                       /* If there is a custom-set Host: name, use it
                          here, or else use real peer host name. */
-                      data->state.aptr.cookiehost?
-                      data->state.aptr.cookiehost:conn->host.name,
+                      data->state.aptr.cookiehost? 
+                      data->state.aptr.cookiehost:conn->host.name, 
                       data->state.up.path,
                       (conn->handler->protocol&CURLPROTO_HTTPS)?
                       TRUE:FALSE);
       Curl_share_unlock(data, CURL_LOCK_DATA_COOKIE);
     }
 #endif
-    else if(!k->http_bodyless && checkprefix("Last-Modified:", headp) &&
+    else if(!k->http_bodyless && checkprefix("Last-Modified:", headp) && 
             (data->set.timecondition || data->set.get_filetime) ) {
-      k->timeofdoc = Curl_getdate_capped(headp + strlen("Last-Modified:"));
+      k->timeofdoc = Curl_getdate_capped(headp + strlen("Last-Modified:")); 
       if(data->set.get_filetime)
         data->info.filetime = k->timeofdoc;
     }
-    else if((checkprefix("WWW-Authenticate:", headp) &&
+    else if((checkprefix("WWW-Authenticate:", headp) && 
              (401 == k->httpcode)) ||
-            (checkprefix("Proxy-authenticate:", headp) &&
+            (checkprefix("Proxy-authenticate:", headp) && 
              (407 == k->httpcode))) {
 
       bool proxy = (k->httpcode == 407) ? TRUE : FALSE;
-      char *auth = Curl_copy_header_value(headp);
+      char *auth = Curl_copy_header_value(headp); 
       if(!auth)
         return CURLE_OUT_OF_MEMORY;
 
@@ -3947,28 +3947,28 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
       if(result)
         return result;
     }
-#ifdef USE_SPNEGO
-    else if(checkprefix("Persistent-Auth", headp)) {
+#ifdef USE_SPNEGO 
+    else if(checkprefix("Persistent-Auth", headp)) { 
       struct negotiatedata *negdata = &conn->negotiate;
       struct auth *authp = &data->state.authhost;
       if(authp->picked == CURLAUTH_NEGOTIATE) {
-        char *persistentauth = Curl_copy_header_value(headp);
+        char *persistentauth = Curl_copy_header_value(headp); 
         if(!persistentauth)
           return CURLE_OUT_OF_MEMORY;
-        negdata->noauthpersist = checkprefix("false", persistentauth)?
-          TRUE:FALSE;
+        negdata->noauthpersist = checkprefix("false", persistentauth)? 
+          TRUE:FALSE; 
         negdata->havenoauthpersist = TRUE;
         infof(data, "Negotiate: noauthpersist -> %d, header part: %s",
           negdata->noauthpersist, persistentauth);
         free(persistentauth);
       }
     }
-#endif
+#endif 
     else if((k->httpcode >= 300 && k->httpcode < 400) &&
-            checkprefix("Location:", headp) &&
+            checkprefix("Location:", headp) && 
             !data->req.location) {
       /* this is the URL that the server advises us to use instead */
-      char *location = Curl_copy_header_value(headp);
+      char *location = Curl_copy_header_value(headp); 
       if(!location)
         return CURLE_OUT_OF_MEMORY;
       if(!*location)
@@ -3991,26 +3991,26 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
         }
       }
     }
-
-#ifdef USE_HSTS
-    /* If enabled, the header is incoming and this is over HTTPS */
-    else if(data->hsts && checkprefix("Strict-Transport-Security:", headp) &&
-            (conn->handler->flags & PROTOPT_SSL)) {
-      CURLcode check =
-        Curl_hsts_parse(data->hsts, data->state.up.hostname,
-                        &headp[ sizeof("Strict-Transport-Security:") -1 ]);
-      if(check)
-        infof(data, "Illegal STS header skipped\n");
-#ifdef DEBUGBUILD
-      else
-        infof(data, "Parsed STS header fine (%zu entries)\n",
-              data->hsts->list.size);
-#endif
-    }
-#endif
-#ifndef CURL_DISABLE_ALTSVC
+ 
+#ifdef USE_HSTS 
     /* If enabled, the header is incoming and this is over HTTPS */
-    else if(data->asi && checkprefix("Alt-Svc:", headp) &&
+    else if(data->hsts && checkprefix("Strict-Transport-Security:", headp) && 
+            (conn->handler->flags & PROTOPT_SSL)) { 
+      CURLcode check = 
+        Curl_hsts_parse(data->hsts, data->state.up.hostname, 
+                        &headp[ sizeof("Strict-Transport-Security:") -1 ]); 
+      if(check) 
+        infof(data, "Illegal STS header skipped\n"); 
+#ifdef DEBUGBUILD 
+      else 
+        infof(data, "Parsed STS header fine (%zu entries)\n", 
+              data->hsts->list.size); 
+#endif 
+    } 
+#endif 
+#ifndef CURL_DISABLE_ALTSVC 
+    /* If enabled, the header is incoming and this is over HTTPS */ 
+    else if(data->asi && checkprefix("Alt-Svc:", headp) && 
             ((conn->handler->flags & PROTOPT_SSL) ||
 #ifdef CURLDEBUG
              /* allow debug builds to circumvent the HTTPS restriction */
@@ -4022,7 +4022,7 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
       /* the ALPN of the current request */
       enum alpnid id = (conn->httpversion == 20) ? ALPN_h2 : ALPN_h1;
       result = Curl_altsvc_parse(data, data->asi,
-                                 &headp[ strlen("Alt-Svc:") ],
+                                 &headp[ strlen("Alt-Svc:") ], 
                                  id, conn->host.name,
                                  curlx_uitous(conn->remote_port));
       if(result)
@@ -4030,7 +4030,7 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
     }
 #endif
     else if(conn->handler->protocol & CURLPROTO_RTSP) {
-      result = Curl_rtsp_parseheader(conn, headp);
+      result = Curl_rtsp_parseheader(conn, headp); 
       if(result)
         return result;
     }
@@ -4043,18 +4043,18 @@ CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
     if(data->set.include_header)
       writetype |= CLIENTWRITE_BODY;
 
-    Curl_debug(data, CURLINFO_HEADER_IN, headp,
-               Curl_dyn_len(&data->state.headerb));
+    Curl_debug(data, CURLINFO_HEADER_IN, headp, 
+               Curl_dyn_len(&data->state.headerb)); 
 
-    result = Curl_client_write(conn, writetype, headp,
-                               Curl_dyn_len(&data->state.headerb));
+    result = Curl_client_write(conn, writetype, headp, 
+                               Curl_dyn_len(&data->state.headerb)); 
     if(result)
       return result;
 
-    data->info.header_size += Curl_dyn_len(&data->state.headerb);
-    data->req.headerbytecount += Curl_dyn_len(&data->state.headerb);
+    data->info.header_size += Curl_dyn_len(&data->state.headerb); 
+    data->req.headerbytecount += Curl_dyn_len(&data->state.headerb); 
 
-    Curl_dyn_reset(&data->state.headerb);
+    Curl_dyn_reset(&data->state.headerb); 
   }
   while(*k->str); /* header line within buffer */