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

1 files changed, 559 insertions, 559 deletions

diff --git a/contrib/libs/curl/lib/multi.c b/contrib/libs/curl/lib/multi.c
index e01e18b33f..f1c9e4dbfb 100644
--- a/contrib/libs/curl/lib/multi.c
+++ b/contrib/libs/curl/lib/multi.c
@@ -158,8 +158,8 @@ static void mstate(struct Curl_easy *data, CURLMstate state
      data->mstate < CURLM_STATE_COMPLETED) {
     long connection_id = -5000;
 
-    if(data->conn) 
-      connection_id = data->conn->connection_id; 
+    if(data->conn)
+      connection_id = data->conn->connection_id;
 
     infof(data,
           "STATE: %s => %s handle %p; line %d (connection #%ld)\n",
@@ -186,17 +186,17 @@ static void mstate(struct Curl_easy *data, CURLMstate state
 #endif
 
 /*
- * We add one of these structs to the sockhash for each socket 
+ * We add one of these structs to the sockhash for each socket
  */
 
 struct Curl_sh_entry {
   struct Curl_hash transfers; /* hash of transfers using this socket */
-  unsigned int action;  /* what combined action READ/WRITE this socket waits 
-                           for */ 
+  unsigned int action;  /* what combined action READ/WRITE this socket waits
+                           for */
   void *socketp; /* settable by users with curl_multi_assign() */
-  unsigned int users; /* number of transfers using this */ 
-  unsigned int readers; /* this many transfers want to read */ 
-  unsigned int writers; /* this many transfers want to write */ 
+  unsigned int users; /* number of transfers using this */
+  unsigned int readers; /* this many transfers want to read */
+  unsigned int writers; /* this many transfers want to write */
 };
 /* bits for 'action' having no bits means this socket is not expecting any
    action */
@@ -207,58 +207,58 @@ struct Curl_sh_entry {
 static struct Curl_sh_entry *sh_getentry(struct Curl_hash *sh,
                                          curl_socket_t s)
 {
-  if(s != CURL_SOCKET_BAD) { 
+  if(s != CURL_SOCKET_BAD) {
     /* only look for proper sockets */
     return Curl_hash_pick(sh, (char *)&s, sizeof(curl_socket_t));
-  } 
+  }
   return NULL;
 }
 
-#define TRHASH_SIZE 13 
-static size_t trhash(void *key, size_t key_length, size_t slots_num) 
-{ 
-  size_t keyval = (size_t)*(struct Curl_easy **)key; 
-  (void) key_length; 
- 
-  return (keyval % slots_num); 
-} 
- 
-static size_t trhash_compare(void *k1, size_t k1_len, void *k2, size_t k2_len) 
-{ 
-  (void)k1_len; 
-  (void)k2_len; 
- 
-  return *(struct Curl_easy **)k1 == *(struct Curl_easy **)k2; 
-} 
- 
-static void trhash_dtor(void *nada) 
-{ 
-  (void)nada; 
-} 
- 
- 
+#define TRHASH_SIZE 13
+static size_t trhash(void *key, size_t key_length, size_t slots_num)
+{
+  size_t keyval = (size_t)*(struct Curl_easy **)key;
+  (void) key_length;
+
+  return (keyval % slots_num);
+}
+
+static size_t trhash_compare(void *k1, size_t k1_len, void *k2, size_t k2_len)
+{
+  (void)k1_len;
+  (void)k2_len;
+
+  return *(struct Curl_easy **)k1 == *(struct Curl_easy **)k2;
+}
+
+static void trhash_dtor(void *nada)
+{
+  (void)nada;
+}
+
+
 /* make sure this socket is present in the hash for this handle */
 static struct Curl_sh_entry *sh_addentry(struct Curl_hash *sh,
-                                         curl_socket_t s) 
+                                         curl_socket_t s)
 {
   struct Curl_sh_entry *there = sh_getentry(sh, s);
   struct Curl_sh_entry *check;
 
-  if(there) { 
+  if(there) {
     /* it is present, return fine */
     return there;
-  } 
+  }
 
   /* not present, add it */
   check = calloc(1, sizeof(struct Curl_sh_entry));
   if(!check)
     return NULL; /* major failure */
 
-  if(Curl_hash_init(&check->transfers, TRHASH_SIZE, trhash, 
-                    trhash_compare, trhash_dtor)) { 
-    free(check); 
-    return NULL; 
-  } 
+  if(Curl_hash_init(&check->transfers, TRHASH_SIZE, trhash,
+                    trhash_compare, trhash_dtor)) {
+    free(check);
+    return NULL;
+  }
 
   /* make/add new hash entry */
   if(!Curl_hash_add(sh, (char *)&s, sizeof(curl_socket_t), check)) {
@@ -272,11 +272,11 @@ static struct Curl_sh_entry *sh_addentry(struct Curl_hash *sh,
 
 
 /* delete the given socket + handle from the hash */
-static void sh_delentry(struct Curl_sh_entry *entry, 
+static void sh_delentry(struct Curl_sh_entry *entry,
                         struct Curl_hash *sh, curl_socket_t s)
 {
-  Curl_hash_destroy(&entry->transfers); 
- 
+  Curl_hash_destroy(&entry->transfers);
+
   /* We remove the hash entry. This will end up in a call to
      sh_freeentry(). */
   Curl_hash_delete(sh, (char *)&s, sizeof(curl_socket_t));
@@ -364,8 +364,8 @@ struct Curl_multi *Curl_multi_handle(int hashsize, /* socket hash */
   if(Curl_conncache_init(&multi->conn_cache, chashsize))
     goto error;
 
-  Curl_llist_init(&multi->msglist, NULL); 
-  Curl_llist_init(&multi->pending, NULL); 
+  Curl_llist_init(&multi->msglist, NULL);
+  Curl_llist_init(&multi->pending, NULL);
 
   multi->multiplexing = TRUE;
 
@@ -444,7 +444,7 @@ CURLMcode curl_multi_add_handle(struct Curl_multi *multi,
 
   /* for multi interface connections, we share DNS cache automatically if the
      easy handle's one is currently not set. */
-  if(!data->dns.hostcache || 
+  if(!data->dns.hostcache ||
      (data->dns.hostcachetype == HCACHE_NONE)) {
     data->dns.hostcache = &multi->hostcache;
     data->dns.hostcachetype = HCACHE_MULTI;
@@ -465,7 +465,7 @@ CURLMcode curl_multi_add_handle(struct Curl_multi *multi,
     data->psl = &multi->psl;
 #endif
 
-  /* We add the new entry last in the list. */ 
+  /* We add the new entry last in the list. */
   data->next = NULL; /* end of the line */
   if(multi->easyp) {
     struct Curl_easy *last = multi->easylp;
@@ -496,16 +496,16 @@ CURLMcode curl_multi_add_handle(struct Curl_multi *multi,
   /* increase the alive-counter */
   multi->num_alive++;
 
-  /* A somewhat crude work-around for a little glitch in Curl_update_timer() 
-     that happens if the lastcall time is set to the same time when the handle 
-     is removed as when the next handle is added, as then the check in 
-     Curl_update_timer() that prevents calling the application multiple times 
-     with the same timer info will not trigger and then the new handle's 
-     timeout will not be notified to the app. 
+  /* A somewhat crude work-around for a little glitch in Curl_update_timer()
+     that happens if the lastcall time is set to the same time when the handle
+     is removed as when the next handle is added, as then the check in
+     Curl_update_timer() that prevents calling the application multiple times
+     with the same timer info will not trigger and then the new handle's
+     timeout will not be notified to the app.
 
      The work-around is thus simply to clear the 'lastcall' variable to force
-     Curl_update_timer() to always trigger a callback to the app when a new 
-     easy handle is added */ 
+     Curl_update_timer() to always trigger a callback to the app when a new
+     easy handle is added */
   memset(&multi->timer_lastcall, 0, sizeof(multi->timer_lastcall));
 
   CONNCACHE_LOCK(data);
@@ -520,7 +520,7 @@ CURLMcode curl_multi_add_handle(struct Curl_multi *multi,
     data->set.no_signal;
   CONNCACHE_UNLOCK(data);
 
-  Curl_update_timer(multi); 
+  Curl_update_timer(multi);
   return CURLM_OK;
 }
 
@@ -540,13 +540,13 @@ static void debug_print_sock_hash(void *p)
 }
 #endif
 
-static CURLcode multi_done(struct Curl_easy *data, 
-                           CURLcode status,  /* an error if this is called 
-                                                after an error was detected */ 
-                           bool premature) 
+static CURLcode multi_done(struct Curl_easy *data,
+                           CURLcode status,  /* an error if this is called
+                                                after an error was detected */
+                           bool premature)
 {
   CURLcode result;
-  struct connectdata *conn = data->conn; 
+  struct connectdata *conn = data->conn;
   unsigned int i;
 
   DEBUGF(infof(data, "multi_done\n"));
@@ -597,15 +597,15 @@ static CURLcode multi_done(struct Curl_easy *data,
 
   CONNCACHE_LOCK(data);
   Curl_detach_connnection(data);
-  if(CONN_INUSE(conn)) { 
+  if(CONN_INUSE(conn)) {
     /* Stop if still used. */
     /* conn->data must not remain pointing to this transfer since it is going
        away! Find another to own it! */
     conn->data = conn->easyq.head->ptr;
     CONNCACHE_UNLOCK(data);
-    DEBUGF(infof(data, "Connection still in use %zu, " 
+    DEBUGF(infof(data, "Connection still in use %zu, "
                  "no more multi_done now!\n",
-                 conn->easyq.size)); 
+                 conn->easyq.size));
     return CURLE_OK;
   }
   conn->data = NULL; /* the connection now has no owner */
@@ -627,7 +627,7 @@ static CURLcode multi_done(struct Curl_easy *data,
 
   /* if data->set.reuse_forbid is TRUE, it means the libcurl client has
      forced us to close this connection. This is ignored for requests taking
-     place in a NTLM/NEGOTIATE authentication handshake 
+     place in a NTLM/NEGOTIATE authentication handshake
 
      if conn->bits.close is TRUE, it means that the connection should be
      closed in spite of all our efforts to be nice, due to protocol
@@ -642,13 +642,13 @@ static CURLcode multi_done(struct Curl_easy *data,
 
   if((data->set.reuse_forbid
 #if defined(USE_NTLM)
-      && !(conn->http_ntlm_state == NTLMSTATE_TYPE2 || 
-           conn->proxy_ntlm_state == NTLMSTATE_TYPE2) 
+      && !(conn->http_ntlm_state == NTLMSTATE_TYPE2 ||
+           conn->proxy_ntlm_state == NTLMSTATE_TYPE2)
+#endif
+#if defined(USE_SPNEGO)
+      && !(conn->http_negotiate_state == GSS_AUTHRECV ||
+           conn->proxy_negotiate_state == GSS_AUTHRECV)
 #endif
-#if defined(USE_SPNEGO) 
-      && !(conn->http_negotiate_state == GSS_AUTHRECV || 
-           conn->proxy_negotiate_state == GSS_AUTHRECV) 
-#endif 
      ) || conn->bits.close
        || (premature && !(conn->handler->flags & PROTOPT_STREAM))) {
     CURLcode res2;
@@ -740,7 +740,7 @@ CURLMcode curl_multi_remove_handle(struct Curl_multi *multi,
     return CURLM_RECURSIVE_API_CALL;
 
   premature = (data->mstate < CURLM_STATE_COMPLETED) ? TRUE : FALSE;
-  easy_owns_conn = (data->conn && (data->conn->data == easy)) ? 
+  easy_owns_conn = (data->conn && (data->conn->data == easy)) ?
     TRUE : FALSE;
 
   /* If the 'state' is not INIT or COMPLETED, we might need to do something
@@ -751,17 +751,17 @@ CURLMcode curl_multi_remove_handle(struct Curl_multi *multi,
     multi->num_alive--;
   }
 
-  if(data->conn && 
+  if(data->conn &&
      data->mstate > CURLM_STATE_DO &&
      data->mstate < CURLM_STATE_COMPLETED) {
     /* Set connection owner so that the DONE function closes it.  We can
        safely do this here since connection is killed. */
-    data->conn->data = easy; 
-    streamclose(data->conn, "Removed with partial response"); 
+    data->conn->data = easy;
+    streamclose(data->conn, "Removed with partial response");
     easy_owns_conn = TRUE;
   }
 
-  if(data->conn) { 
+  if(data->conn) {
 
     /* we must call multi_done() here (if we still own the connection) so that
        we don't leave a half-baked one around */
@@ -772,7 +772,7 @@ CURLMcode curl_multi_remove_handle(struct Curl_multi *multi,
 
          Note that this ignores the return code simply because there's
          nothing really useful to do with it anyway! */
-      (void)multi_done(data, data->result, premature); 
+      (void)multi_done(data, data->result, premature);
     }
   }
 
@@ -855,14 +855,14 @@ CURLMcode curl_multi_remove_handle(struct Curl_multi *multi,
      We do not touch the easy handle here! */
   multi->num_easy--; /* one less to care about now */
 
-  Curl_update_timer(multi); 
+  Curl_update_timer(multi);
   return CURLM_OK;
 }
 
-/* Return TRUE if the application asked for multiplexing */ 
-bool Curl_multiplex_wanted(const struct Curl_multi *multi) 
+/* Return TRUE if the application asked for multiplexing */
+bool Curl_multiplex_wanted(const struct Curl_multi *multi)
 {
-  return (multi && (multi->multiplexing)); 
+  return (multi && (multi->multiplexing));
 }
 
 /*
@@ -873,10 +873,10 @@ bool Curl_multiplex_wanted(const struct Curl_multi *multi)
  */
 void Curl_detach_connnection(struct Curl_easy *data)
 {
-  struct connectdata *conn = data->conn; 
-  if(conn) 
-    Curl_llist_remove(&conn->easyq, &data->conn_queue, NULL); 
-  data->conn = NULL; 
+  struct connectdata *conn = data->conn;
+  if(conn)
+    Curl_llist_remove(&conn->easyq, &data->conn_queue, NULL);
+  data->conn = NULL;
 }
 
 /*
@@ -884,18 +884,18 @@ void Curl_detach_connnection(struct Curl_easy *data)
  *
  * This is the only function that should assign data->conn
  */
-void Curl_attach_connnection(struct Curl_easy *data, 
-                             struct connectdata *conn) 
-{ 
-  DEBUGASSERT(!data->conn); 
-  DEBUGASSERT(conn); 
-  data->conn = conn; 
-  Curl_llist_insert_next(&conn->easyq, conn->easyq.tail, data, 
-                         &data->conn_queue); 
-} 
- 
+void Curl_attach_connnection(struct Curl_easy *data,
+                             struct connectdata *conn)
+{
+  DEBUGASSERT(!data->conn);
+  DEBUGASSERT(conn);
+  data->conn = conn;
+  Curl_llist_insert_next(&conn->easyq, conn->easyq.tail, data,
+                         &data->conn_queue);
+}
+
 static int waitconnect_getsock(struct connectdata *conn,
-                               curl_socket_t *sock) 
+                               curl_socket_t *sock)
 {
   int i;
   int s = 0;
@@ -904,7 +904,7 @@ static int waitconnect_getsock(struct connectdata *conn,
 #ifdef USE_SSL
 #ifndef CURL_DISABLE_PROXY
   if(CONNECT_FIRSTSOCKET_PROXY_SSL())
-    return Curl_ssl_getsock(conn, sock); 
+    return Curl_ssl_getsock(conn, sock);
 #endif
 #endif
 
@@ -914,13 +914,13 @@ static int waitconnect_getsock(struct connectdata *conn,
   for(i = 0; i<2; i++) {
     if(conn->tempsock[i] != CURL_SOCKET_BAD) {
       sock[s] = conn->tempsock[i];
-      rc |= GETSOCK_WRITESOCK(s); 
-#ifdef ENABLE_QUIC 
-      if(conn->transport == TRNSPRT_QUIC) 
-        /* when connecting QUIC, we want to read the socket too */ 
-        rc |= GETSOCK_READSOCK(s); 
-#endif 
-      s++; 
+      rc |= GETSOCK_WRITESOCK(s);
+#ifdef ENABLE_QUIC
+      if(conn->transport == TRNSPRT_QUIC)
+        /* when connecting QUIC, we want to read the socket too */
+        rc |= GETSOCK_READSOCK(s);
+#endif
+      s++;
     }
   }
 
@@ -928,7 +928,7 @@ static int waitconnect_getsock(struct connectdata *conn,
 }
 
 static int waitproxyconnect_getsock(struct connectdata *conn,
-                                    curl_socket_t *sock) 
+                                    curl_socket_t *sock)
 {
   sock[0] = conn->sock[FIRSTSOCKET];
 
@@ -941,48 +941,48 @@ static int waitproxyconnect_getsock(struct connectdata *conn,
 }
 
 static int domore_getsock(struct connectdata *conn,
-                          curl_socket_t *socks) 
+                          curl_socket_t *socks)
 {
   if(conn && conn->handler->domore_getsock)
-    return conn->handler->domore_getsock(conn, socks); 
+    return conn->handler->domore_getsock(conn, socks);
   return GETSOCK_BLANK;
 }
 
-static int doing_getsock(struct connectdata *conn, 
-                         curl_socket_t *socks) 
-{ 
-  if(conn && conn->handler->doing_getsock) 
-    return conn->handler->doing_getsock(conn, socks); 
-  return GETSOCK_BLANK; 
-} 
- 
-static int protocol_getsock(struct connectdata *conn, 
-                            curl_socket_t *socks) 
-{ 
-  if(conn->handler->proto_getsock) 
-    return conn->handler->proto_getsock(conn, socks); 
-  /* Backup getsock logic. Since there is a live socket in use, we must wait 
-     for it or it will be removed from watching when the multi_socket API is 
-     used. */ 
-  socks[0] = conn->sock[FIRSTSOCKET]; 
-  return GETSOCK_READSOCK(0) | GETSOCK_WRITESOCK(0); 
-} 
- 
-/* returns bitmapped flags for this handle and its sockets. The 'socks[]' 
-   array contains MAX_SOCKSPEREASYHANDLE entries. */ 
+static int doing_getsock(struct connectdata *conn,
+                         curl_socket_t *socks)
+{
+  if(conn && conn->handler->doing_getsock)
+    return conn->handler->doing_getsock(conn, socks);
+  return GETSOCK_BLANK;
+}
+
+static int protocol_getsock(struct connectdata *conn,
+                            curl_socket_t *socks)
+{
+  if(conn->handler->proto_getsock)
+    return conn->handler->proto_getsock(conn, socks);
+  /* Backup getsock logic. Since there is a live socket in use, we must wait
+     for it or it will be removed from watching when the multi_socket API is
+     used. */
+  socks[0] = conn->sock[FIRSTSOCKET];
+  return GETSOCK_READSOCK(0) | GETSOCK_WRITESOCK(0);
+}
+
+/* returns bitmapped flags for this handle and its sockets. The 'socks[]'
+   array contains MAX_SOCKSPEREASYHANDLE entries. */
 static int multi_getsock(struct Curl_easy *data,
-                         curl_socket_t *socks) 
+                         curl_socket_t *socks)
 {
   /* The no connection case can happen when this is called from
      curl_multi_remove_handle() => singlesocket() => multi_getsock().
   */
-  if(!data->conn) 
+  if(!data->conn)
     return 0;
 
   if(data->mstate > CURLM_STATE_CONNECT &&
      data->mstate < CURLM_STATE_COMPLETED) {
     /* Set up ownership correctly */
-    data->conn->data = data; 
+    data->conn->data = data;
   }
 
   switch(data->mstate) {
@@ -990,30 +990,30 @@ static int multi_getsock(struct Curl_easy *data,
     return 0;
 
   case CURLM_STATE_WAITRESOLVE:
-    return Curl_resolv_getsock(data->conn, socks); 
+    return Curl_resolv_getsock(data->conn, socks);
 
   case CURLM_STATE_PROTOCONNECT:
   case CURLM_STATE_SENDPROTOCONNECT:
-    return protocol_getsock(data->conn, socks); 
+    return protocol_getsock(data->conn, socks);
 
   case CURLM_STATE_DO:
   case CURLM_STATE_DOING:
-    return doing_getsock(data->conn, socks); 
+    return doing_getsock(data->conn, socks);
 
   case CURLM_STATE_WAITPROXYCONNECT:
-    return waitproxyconnect_getsock(data->conn, socks); 
+    return waitproxyconnect_getsock(data->conn, socks);
 
   case CURLM_STATE_WAITCONNECT:
-    return waitconnect_getsock(data->conn, socks); 
+    return waitconnect_getsock(data->conn, socks);
 
   case CURLM_STATE_DO_MORE:
-    return domore_getsock(data->conn, socks); 
+    return domore_getsock(data->conn, socks);
 
   case CURLM_STATE_DO_DONE: /* since is set after DO is completed, we switch
                                to waiting for the same as the *PERFORM
                                states */
   case CURLM_STATE_PERFORM:
-    return Curl_single_getsock(data->conn, socks); 
+    return Curl_single_getsock(data->conn, socks);
   }
 
 }
@@ -1039,7 +1039,7 @@ CURLMcode curl_multi_fdset(struct Curl_multi *multi,
 
   data = multi->easyp;
   while(data) {
-    int bitmap = multi_getsock(data, sockbunch); 
+    int bitmap = multi_getsock(data, sockbunch);
 
     for(i = 0; i< MAX_SOCKSPEREASYHANDLE; i++) {
       curl_socket_t s = CURL_SOCKET_BAD;
@@ -1069,11 +1069,11 @@ CURLMcode curl_multi_fdset(struct Curl_multi *multi,
 
 #define NUM_POLLS_ON_STACK 10
 
-static CURLMcode Curl_multi_wait(struct Curl_multi *multi, 
-                                 struct curl_waitfd extra_fds[], 
-                                 unsigned int extra_nfds, 
-                                 int timeout_ms, 
-                                 int *ret, 
+static CURLMcode Curl_multi_wait(struct Curl_multi *multi,
+                                 struct curl_waitfd extra_fds[],
+                                 unsigned int extra_nfds,
+                                 int timeout_ms,
+                                 int *ret,
                                  bool extrawait, /* when no socket, wait */
                                  bool use_wakeup)
 {
@@ -1086,7 +1086,7 @@ static CURLMcode Curl_multi_wait(struct Curl_multi *multi,
   long timeout_internal;
   int retcode = 0;
   struct pollfd a_few_on_stack[NUM_POLLS_ON_STACK];
-  struct pollfd *ufds = &a_few_on_stack[0]; 
+  struct pollfd *ufds = &a_few_on_stack[0];
   bool ufds_malloc = FALSE;
 
   if(!GOOD_MULTI_HANDLE(multi))
@@ -1101,7 +1101,7 @@ static CURLMcode Curl_multi_wait(struct Curl_multi *multi,
   /* Count up how many fds we have from the multi handle */
   data = multi->easyp;
   while(data) {
-    bitmap = multi_getsock(data, sockbunch); 
+    bitmap = multi_getsock(data, sockbunch);
 
     for(i = 0; i< MAX_SOCKSPEREASYHANDLE; i++) {
       curl_socket_t s = CURL_SOCKET_BAD;
@@ -1138,15 +1138,15 @@ static CURLMcode Curl_multi_wait(struct Curl_multi *multi,
   }
 #endif
 
-  if(nfds > NUM_POLLS_ON_STACK) { 
-    /* 'nfds' is a 32 bit value and 'struct pollfd' is typically 8 bytes 
-       big, so at 2^29 sockets this value might wrap. When a process gets 
-       the capability to actually handle over 500 million sockets this 
-       calculation needs a integer overflow check. */ 
-    ufds = malloc(nfds * sizeof(struct pollfd)); 
-    if(!ufds) 
-      return CURLM_OUT_OF_MEMORY; 
-    ufds_malloc = TRUE; 
+  if(nfds > NUM_POLLS_ON_STACK) {
+    /* 'nfds' is a 32 bit value and 'struct pollfd' is typically 8 bytes
+       big, so at 2^29 sockets this value might wrap. When a process gets
+       the capability to actually handle over 500 million sockets this
+       calculation needs a integer overflow check. */
+    ufds = malloc(nfds * sizeof(struct pollfd));
+    if(!ufds)
+      return CURLM_OUT_OF_MEMORY;
+    ufds_malloc = TRUE;
   }
   nfds = 0;
 
@@ -1157,7 +1157,7 @@ static CURLMcode Curl_multi_wait(struct Curl_multi *multi,
     /* Add the curl handles to our pollfds first */
     data = multi->easyp;
     while(data) {
-      bitmap = multi_getsock(data, sockbunch); 
+      bitmap = multi_getsock(data, sockbunch);
 
       for(i = 0; i < MAX_SOCKSPEREASYHANDLE; i++) {
         curl_socket_t s = CURL_SOCKET_BAD;
@@ -1258,22 +1258,22 @@ static CURLMcode Curl_multi_wait(struct Curl_multi *multi,
     *ret = retcode;
   if(!extrawait || nfds)
     /* if any socket was checked */
-    ; 
-  else { 
-    long sleep_ms = 0; 
-
-    /* Avoid busy-looping when there's nothing particular to wait for */ 
-    if(!curl_multi_timeout(multi, &sleep_ms) && sleep_ms) { 
-      if(sleep_ms > timeout_ms) 
-        sleep_ms = timeout_ms; 
+    ;
+  else {
+    long sleep_ms = 0;
+
+    /* Avoid busy-looping when there's nothing particular to wait for */
+    if(!curl_multi_timeout(multi, &sleep_ms) && sleep_ms) {
+      if(sleep_ms > timeout_ms)
+        sleep_ms = timeout_ms;
       /* when there are no easy handles in the multi, this holds a -1
          timeout */
       else if(sleep_ms < 0)
         sleep_ms = timeout_ms;
       Curl_wait_ms(sleep_ms);
-    } 
-  } 
- 
+    }
+  }
+
   return CURLM_OK;
 }
 
@@ -1286,12 +1286,12 @@ CURLMcode curl_multi_wait(struct Curl_multi *multi,
   return Curl_multi_wait(multi, extra_fds, extra_nfds, timeout_ms, ret, FALSE,
                          FALSE);
 }
- 
-CURLMcode curl_multi_poll(struct Curl_multi *multi, 
-                          struct curl_waitfd extra_fds[], 
-                          unsigned int extra_nfds, 
-                          int timeout_ms, 
-                          int *ret) 
+
+CURLMcode curl_multi_poll(struct Curl_multi *multi,
+                          struct curl_waitfd extra_fds[],
+                          unsigned int extra_nfds,
+                          int timeout_ms,
+                          int *ret)
 {
   return Curl_multi_wait(multi, extra_fds, extra_nfds, timeout_ms, ret, TRUE,
                          TRUE);
@@ -1379,7 +1379,7 @@ CURLMcode Curl_multi_add_perform(struct Curl_multi *multi,
 
     /* take this handle to the perform state right away */
     multistate(data, CURLM_STATE_PERFORM);
-    Curl_attach_connnection(data, conn); 
+    Curl_attach_connnection(data, conn);
     k->keepon |= KEEP_RECV; /* setup to receive! */
   }
   return rc;
@@ -1389,7 +1389,7 @@ CURLMcode Curl_multi_add_perform(struct Curl_multi *multi,
  * do_complete is called when the DO actions are complete.
  *
  * We init chunking and trailer bits to their default values here immediately
- * before receiving any header data for the current request. 
+ * before receiving any header data for the current request.
  */
 static void do_complete(struct connectdata *conn)
 {
@@ -1397,15 +1397,15 @@ static void do_complete(struct connectdata *conn)
   Curl_pgrsTime(conn->data, TIMER_PRETRANSFER);
 }
 
-static CURLcode multi_do(struct Curl_easy *data, bool *done) 
+static CURLcode multi_do(struct Curl_easy *data, bool *done)
 {
   CURLcode result = CURLE_OK;
-  struct connectdata *conn = data->conn; 
+  struct connectdata *conn = data->conn;
 
-  DEBUGASSERT(conn); 
-  DEBUGASSERT(conn->handler); 
+  DEBUGASSERT(conn);
+  DEBUGASSERT(conn->handler);
   DEBUGASSERT(conn->data == data);
- 
+
   if(conn->handler->do_it) {
     /* generic protocol-specific function pointer set in curl_connect() */
     result = conn->handler->do_it(conn, done);
@@ -1442,108 +1442,108 @@ static CURLcode multi_do_more(struct connectdata *conn, int *complete)
   return result;
 }
 
-/* 
- * We are doing protocol-specific connecting and this is being called over and 
- * over from the multi interface until the connection phase is done on 
- * protocol layer. 
- */ 
- 
-static CURLcode protocol_connecting(struct connectdata *conn, 
-                                    bool *done) 
-{ 
-  CURLcode result = CURLE_OK; 
- 
-  if(conn && conn->handler->connecting) { 
-    *done = FALSE; 
-    result = conn->handler->connecting(conn, done); 
-  } 
-  else 
-    *done = TRUE; 
- 
-  return result; 
-} 
- 
-/* 
- * We are DOING this is being called over and over from the multi interface 
- * until the DOING phase is done on protocol layer. 
- */ 
- 
-static CURLcode protocol_doing(struct connectdata *conn, bool *done) 
-{ 
-  CURLcode result = CURLE_OK; 
- 
-  if(conn && conn->handler->doing) { 
-    *done = FALSE; 
-    result = conn->handler->doing(conn, done); 
-  } 
-  else 
-    *done = TRUE; 
- 
-  return result; 
-} 
- 
-/* 
- * We have discovered that the TCP connection has been successful, we can now 
- * proceed with some action. 
- * 
- */ 
-static CURLcode protocol_connect(struct connectdata *conn, 
-                                 bool *protocol_done) 
-{ 
-  CURLcode result = CURLE_OK; 
- 
-  DEBUGASSERT(conn); 
-  DEBUGASSERT(protocol_done); 
- 
-  *protocol_done = FALSE; 
- 
-  if(conn->bits.tcpconnect[FIRSTSOCKET] && conn->bits.protoconnstart) { 
-    /* We already are connected, get back. This may happen when the connect 
-       worked fine in the first call, like when we connect to a local server 
-       or proxy. Note that we don't know if the protocol is actually done. 
- 
-       Unless this protocol doesn't have any protocol-connect callback, as 
-       then we know we're done. */ 
-    if(!conn->handler->connecting) 
-      *protocol_done = TRUE; 
- 
-    return CURLE_OK; 
-  } 
- 
-  if(!conn->bits.protoconnstart) { 
+/*
+ * We are doing protocol-specific connecting and this is being called over and
+ * over from the multi interface until the connection phase is done on
+ * protocol layer.
+ */
+
+static CURLcode protocol_connecting(struct connectdata *conn,
+                                    bool *done)
+{
+  CURLcode result = CURLE_OK;
+
+  if(conn && conn->handler->connecting) {
+    *done = FALSE;
+    result = conn->handler->connecting(conn, done);
+  }
+  else
+    *done = TRUE;
+
+  return result;
+}
+
+/*
+ * We are DOING this is being called over and over from the multi interface
+ * until the DOING phase is done on protocol layer.
+ */
+
+static CURLcode protocol_doing(struct connectdata *conn, bool *done)
+{
+  CURLcode result = CURLE_OK;
+
+  if(conn && conn->handler->doing) {
+    *done = FALSE;
+    result = conn->handler->doing(conn, done);
+  }
+  else
+    *done = TRUE;
+
+  return result;
+}
+
+/*
+ * We have discovered that the TCP connection has been successful, we can now
+ * proceed with some action.
+ *
+ */
+static CURLcode protocol_connect(struct connectdata *conn,
+                                 bool *protocol_done)
+{
+  CURLcode result = CURLE_OK;
+
+  DEBUGASSERT(conn);
+  DEBUGASSERT(protocol_done);
+
+  *protocol_done = FALSE;
+
+  if(conn->bits.tcpconnect[FIRSTSOCKET] && conn->bits.protoconnstart) {
+    /* We already are connected, get back. This may happen when the connect
+       worked fine in the first call, like when we connect to a local server
+       or proxy. Note that we don't know if the protocol is actually done.
+
+       Unless this protocol doesn't have any protocol-connect callback, as
+       then we know we're done. */
+    if(!conn->handler->connecting)
+      *protocol_done = TRUE;
+
+    return CURLE_OK;
+  }
+
+  if(!conn->bits.protoconnstart) {
 #ifndef CURL_DISABLE_PROXY
-    result = Curl_proxy_connect(conn, FIRSTSOCKET); 
-    if(result) 
-      return result; 
- 
-    if(CONNECT_FIRSTSOCKET_PROXY_SSL()) 
-      /* wait for HTTPS proxy SSL initialization to complete */ 
-      return CURLE_OK; 
- 
-    if(conn->bits.tunnel_proxy && conn->bits.httpproxy && 
-       Curl_connect_ongoing(conn)) 
-      /* when using an HTTP tunnel proxy, await complete tunnel establishment 
-         before proceeding further. Return CURLE_OK so we'll be called again */ 
-      return CURLE_OK; 
+    result = Curl_proxy_connect(conn, FIRSTSOCKET);
+    if(result)
+      return result;
+
+    if(CONNECT_FIRSTSOCKET_PROXY_SSL())
+      /* wait for HTTPS proxy SSL initialization to complete */
+      return CURLE_OK;
+
+    if(conn->bits.tunnel_proxy && conn->bits.httpproxy &&
+       Curl_connect_ongoing(conn))
+      /* when using an HTTP tunnel proxy, await complete tunnel establishment
+         before proceeding further. Return CURLE_OK so we'll be called again */
+      return CURLE_OK;
 #endif
-    if(conn->handler->connect_it) { 
-      /* is there a protocol-specific connect() procedure? */ 
- 
-      /* Call the protocol-specific connect function */ 
-      result = conn->handler->connect_it(conn, protocol_done); 
-    } 
-    else 
-      *protocol_done = TRUE; 
- 
-    /* it has started, possibly even completed but that knowledge isn't stored 
-       in this bit! */ 
-    if(!result) 
-      conn->bits.protoconnstart = TRUE; 
-  } 
- 
-  return result; /* pass back status */ 
-} 
- 
+    if(conn->handler->connect_it) {
+      /* is there a protocol-specific connect() procedure? */
+
+      /* Call the protocol-specific connect function */
+      result = conn->handler->connect_it(conn, protocol_done);
+    }
+    else
+      *protocol_done = TRUE;
+
+    /* it has started, possibly even completed but that knowledge isn't stored
+       in this bit! */
+    if(!result)
+      conn->bits.protoconnstart = TRUE;
+  }
+
+  return result; /* pass back status */
+}
+
 /*
  * Curl_preconnect() is called immediately before a connect starts. When a
  * redirect is followed, this is then called multiple times during a single
@@ -1558,7 +1558,7 @@ CURLcode Curl_preconnect(struct Curl_easy *data)
   }
   return CURLE_OK;
 }
- 
+
 
 static CURLMcode multi_runsingle(struct Curl_multi *multi,
                                  struct curltime *nowp,
@@ -1567,7 +1567,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
   struct Curl_message *msg = NULL;
   bool connected;
   bool async;
-  bool protocol_connected = FALSE; 
+  bool protocol_connected = FALSE;
   bool dophase_done = FALSE;
   bool done = FALSE;
   CURLMcode rc;
@@ -1588,47 +1588,47 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
 
     if(multi_ischanged(multi, TRUE)) {
       DEBUGF(infof(data, "multi changed, check CONNECT_PEND queue!\n"));
-      process_pending_handles(multi); /* multiplexed */ 
+      process_pending_handles(multi); /* multiplexed */
     }
 
-    if(data->conn && data->mstate > CURLM_STATE_CONNECT && 
+    if(data->conn && data->mstate > CURLM_STATE_CONNECT &&
        data->mstate < CURLM_STATE_COMPLETED) {
       /* Make sure we set the connection's current owner */
-      data->conn->data = data; 
+      data->conn->data = data;
     }
 
-    if(data->conn && 
+    if(data->conn &&
        (data->mstate >= CURLM_STATE_CONNECT) &&
        (data->mstate < CURLM_STATE_COMPLETED)) {
       /* we need to wait for the connect state as only then is the start time
          stored, but we must not check already completed handles */
       timeout_ms = Curl_timeleft(data, nowp,
-                                 (data->mstate <= CURLM_STATE_DO)? 
+                                 (data->mstate <= CURLM_STATE_DO)?
                                  TRUE:FALSE);
 
       if(timeout_ms < 0) {
         /* Handle timed out */
         if(data->mstate == CURLM_STATE_WAITRESOLVE)
-          failf(data, "Resolving timed out after %" CURL_FORMAT_TIMEDIFF_T 
-                " milliseconds", 
+          failf(data, "Resolving timed out after %" CURL_FORMAT_TIMEDIFF_T
+                " milliseconds",
                 Curl_timediff(*nowp, data->progress.t_startsingle));
         else if(data->mstate == CURLM_STATE_WAITCONNECT)
-          failf(data, "Connection timed out after %" CURL_FORMAT_TIMEDIFF_T 
-                " milliseconds", 
+          failf(data, "Connection timed out after %" CURL_FORMAT_TIMEDIFF_T
+                " milliseconds",
                 Curl_timediff(*nowp, data->progress.t_startsingle));
         else {
-          struct SingleRequest *k = &data->req; 
+          struct SingleRequest *k = &data->req;
           if(k->size != -1) {
-            failf(data, "Operation timed out after %" CURL_FORMAT_TIMEDIFF_T 
-                  " milliseconds with %" CURL_FORMAT_CURL_OFF_T " out of %" 
+            failf(data, "Operation timed out after %" CURL_FORMAT_TIMEDIFF_T
+                  " milliseconds with %" CURL_FORMAT_CURL_OFF_T " out of %"
                   CURL_FORMAT_CURL_OFF_T " bytes received",
                   Curl_timediff(*nowp, data->progress.t_startsingle),
                   k->bytecount, k->size);
           }
           else {
-            failf(data, "Operation timed out after %" CURL_FORMAT_TIMEDIFF_T 
-                  " milliseconds with %" CURL_FORMAT_CURL_OFF_T 
-                  " bytes received", 
+            failf(data, "Operation timed out after %" CURL_FORMAT_TIMEDIFF_T
+                  " milliseconds with %" CURL_FORMAT_CURL_OFF_T
+                  " bytes received",
                   Curl_timediff(*nowp, data->progress.t_startsingle),
                   k->bytecount);
           }
@@ -1636,11 +1636,11 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
 
         /* Force connection closed if the connection has indeed been used */
         if(data->mstate > CURLM_STATE_DO) {
-          streamclose(data->conn, "Disconnected with pending data"); 
+          streamclose(data->conn, "Disconnected with pending data");
           stream_error = TRUE;
         }
         result = CURLE_OPERATION_TIMEDOUT;
-        (void)multi_done(data, result, TRUE); 
+        (void)multi_done(data, result, TRUE);
         /* Skip the statemachine and go directly to error handling section. */
         goto statemachine_end;
       }
@@ -1672,13 +1672,13 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
         break;
 
       *nowp = Curl_pgrsTime(data, TIMER_STARTSINGLE);
-      if(data->set.timeout) 
-        Curl_expire(data, data->set.timeout, EXPIRE_TIMEOUT); 
- 
-      if(data->set.connecttimeout) 
-        Curl_expire(data, data->set.connecttimeout, EXPIRE_CONNECTTIMEOUT); 
- 
-      result = Curl_connect(data, &async, &protocol_connected); 
+      if(data->set.timeout)
+        Curl_expire(data, data->set.timeout, EXPIRE_TIMEOUT);
+
+      if(data->set.connecttimeout)
+        Curl_expire(data, data->set.connecttimeout, EXPIRE_CONNECTTIMEOUT);
+
+      result = Curl_connect(data, &async, &protocol_connected);
       if(CURLE_NO_CONNECTION_AVAILABLE == result) {
         /* There was no connection available. We will go to the pending
            state and wait for an available connection. */
@@ -1690,31 +1690,31 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
         result = CURLE_OK;
         break;
       }
-      else if(data->state.previouslypending) { 
-        /* this transfer comes from the pending queue so try move another */ 
-        infof(data, "Transfer was pending, now try another\n"); 
-        process_pending_handles(data->multi); 
-      } 
+      else if(data->state.previouslypending) {
+        /* this transfer comes from the pending queue so try move another */
+        infof(data, "Transfer was pending, now try another\n");
+        process_pending_handles(data->multi);
+      }
 
       if(!result) {
-        if(async) 
-          /* We're now waiting for an asynchronous name lookup */ 
-          multistate(data, CURLM_STATE_WAITRESOLVE); 
+        if(async)
+          /* We're now waiting for an asynchronous name lookup */
+          multistate(data, CURLM_STATE_WAITRESOLVE);
         else {
-          /* after the connect has been sent off, go WAITCONNECT unless the 
-             protocol connect is already done and we can go directly to 
-             WAITDO or DO! */ 
-          rc = CURLM_CALL_MULTI_PERFORM; 
- 
-          if(protocol_connected) 
-            multistate(data, CURLM_STATE_DO); 
+          /* after the connect has been sent off, go WAITCONNECT unless the
+             protocol connect is already done and we can go directly to
+             WAITDO or DO! */
+          rc = CURLM_CALL_MULTI_PERFORM;
+
+          if(protocol_connected)
+            multistate(data, CURLM_STATE_DO);
           else {
 #ifndef CURL_DISABLE_HTTP
-            if(Curl_connect_ongoing(data->conn)) 
-              multistate(data, CURLM_STATE_WAITPROXYCONNECT); 
-            else 
+            if(Curl_connect_ongoing(data->conn))
+              multistate(data, CURLM_STATE_WAITPROXYCONNECT);
+            else
 #endif
-              multistate(data, CURLM_STATE_WAITCONNECT); 
+              multistate(data, CURLM_STATE_WAITCONNECT);
           }
         }
       }
@@ -1724,10 +1724,10 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
       /* awaiting an asynch name resolve to complete */
     {
       struct Curl_dns_entry *dns = NULL;
-      struct connectdata *conn = data->conn; 
+      struct connectdata *conn = data->conn;
       const char *hostname;
 
-      DEBUGASSERT(conn); 
+      DEBUGASSERT(conn);
 #ifndef CURL_DISABLE_PROXY
       if(conn->bits.httpproxy)
         hostname = conn->http_proxy.host.name;
@@ -1751,7 +1751,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
       }
 
       if(!dns)
-        result = Curl_resolv_check(data->conn, &dns); 
+        result = Curl_resolv_check(data->conn, &dns);
 
       /* Update sockets here, because the socket(s) may have been
          closed and the application thus needs to be told, even if it
@@ -1764,20 +1764,20 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
       if(dns) {
         /* Perform the next step in the connection phase, and then move on
            to the WAITCONNECT state */
-        result = Curl_once_resolved(data->conn, &protocol_connected); 
+        result = Curl_once_resolved(data->conn, &protocol_connected);
 
         if(result)
           /* if Curl_once_resolved() returns failure, the connection struct
              is already freed and gone */
-          data->conn = NULL; /* no more connection */ 
+          data->conn = NULL; /* no more connection */
         else {
           /* call again please so that we get the next socket setup */
           rc = CURLM_CALL_MULTI_PERFORM;
-          if(protocol_connected) 
-            multistate(data, CURLM_STATE_DO); 
+          if(protocol_connected)
+            multistate(data, CURLM_STATE_DO);
           else {
 #ifndef CURL_DISABLE_HTTP
-            if(Curl_connect_ongoing(data->conn)) 
+            if(Curl_connect_ongoing(data->conn))
               multistate(data, CURLM_STATE_WAITPROXYCONNECT);
             else
 #endif
@@ -1797,14 +1797,14 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
 #ifndef CURL_DISABLE_HTTP
     case CURLM_STATE_WAITPROXYCONNECT:
       /* this is HTTP-specific, but sending CONNECT to a proxy is HTTP... */
-      DEBUGASSERT(data->conn); 
-      result = Curl_http_connect(data->conn, &protocol_connected); 
+      DEBUGASSERT(data->conn);
+      result = Curl_http_connect(data->conn, &protocol_connected);
 #ifndef CURL_DISABLE_PROXY
-      if(data->conn->bits.proxy_connect_closed) { 
+      if(data->conn->bits.proxy_connect_closed) {
         rc = CURLM_CALL_MULTI_PERFORM;
         /* connect back to proxy again */
         result = CURLE_OK;
-        multi_done(data, CURLE_OK, FALSE); 
+        multi_done(data, CURLE_OK, FALSE);
         multistate(data, CURLM_STATE_CONNECT);
       }
       else
@@ -1828,8 +1828,8 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
 
     case CURLM_STATE_WAITCONNECT:
       /* awaiting a completion of an asynch TCP connect */
-      DEBUGASSERT(data->conn); 
-      result = Curl_is_connected(data->conn, FIRSTSOCKET, &connected); 
+      DEBUGASSERT(data->conn);
+      result = Curl_is_connected(data->conn, FIRSTSOCKET, &connected);
       if(connected && !result) {
 #ifndef CURL_DISABLE_HTTP
         if(
@@ -1854,43 +1854,43 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
       }
       else if(result) {
         /* failure detected */
-        Curl_posttransfer(data); 
-        multi_done(data, result, TRUE); 
+        Curl_posttransfer(data);
+        multi_done(data, result, TRUE);
         stream_error = TRUE;
         break;
       }
       break;
 
     case CURLM_STATE_SENDPROTOCONNECT:
-      result = protocol_connect(data->conn, &protocol_connected); 
-      if(!result && !protocol_connected) 
+      result = protocol_connect(data->conn, &protocol_connected);
+      if(!result && !protocol_connected)
         /* switch to waiting state */
         multistate(data, CURLM_STATE_PROTOCONNECT);
       else if(!result) {
         /* protocol connect has completed, go WAITDO or DO */
-        multistate(data, CURLM_STATE_DO); 
+        multistate(data, CURLM_STATE_DO);
         rc = CURLM_CALL_MULTI_PERFORM;
       }
       else {
         /* failure detected */
         Curl_posttransfer(data);
-        multi_done(data, result, TRUE); 
+        multi_done(data, result, TRUE);
         stream_error = TRUE;
       }
       break;
 
     case CURLM_STATE_PROTOCONNECT:
       /* protocol-specific connect phase */
-      result = protocol_connecting(data->conn, &protocol_connected); 
-      if(!result && protocol_connected) { 
+      result = protocol_connecting(data->conn, &protocol_connected);
+      if(!result && protocol_connected) {
         /* after the connect has completed, go WAITDO or DO */
-        multistate(data, CURLM_STATE_DO); 
+        multistate(data, CURLM_STATE_DO);
         rc = CURLM_CALL_MULTI_PERFORM;
       }
       else if(result) {
         /* failure detected */
         Curl_posttransfer(data);
-        multi_done(data, result, TRUE); 
+        multi_done(data, result, TRUE);
         stream_error = TRUE;
       }
       break;
@@ -1898,32 +1898,32 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
     case CURLM_STATE_DO:
       if(data->set.connect_only) {
         /* keep connection open for application to use the socket */
-        connkeep(data->conn, "CONNECT_ONLY"); 
+        connkeep(data->conn, "CONNECT_ONLY");
         multistate(data, CURLM_STATE_DONE);
         result = CURLE_OK;
         rc = CURLM_CALL_MULTI_PERFORM;
       }
       else {
         /* Perform the protocol's DO action */
-        result = multi_do(data, &dophase_done); 
+        result = multi_do(data, &dophase_done);
 
-        /* When multi_do() returns failure, data->conn might be NULL! */ 
+        /* When multi_do() returns failure, data->conn might be NULL! */
 
         if(!result) {
           if(!dophase_done) {
-#ifndef CURL_DISABLE_FTP 
+#ifndef CURL_DISABLE_FTP
             /* some steps needed for wildcard matching */
             if(data->state.wildcardmatch) {
               struct WildcardData *wc = &data->wildcard;
               if(wc->state == CURLWC_DONE || wc->state == CURLWC_SKIP) {
                 /* skip some states if it is important */
-                multi_done(data, CURLE_OK, FALSE); 
+                multi_done(data, CURLE_OK, FALSE);
                 multistate(data, CURLM_STATE_DONE);
                 rc = CURLM_CALL_MULTI_PERFORM;
                 break;
               }
             }
-#endif 
+#endif
             /* DO was not completed in one function call, we must continue
                DOING... */
             multistate(data, CURLM_STATE_DOING);
@@ -1931,7 +1931,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
           }
 
           /* after DO, go DO_DONE... or DO_MORE */
-          else if(data->conn->bits.do_more) { 
+          else if(data->conn->bits.do_more) {
             /* we're supposed to do more, but we need to sit down, relax
                and wait a little while first */
             multistate(data, CURLM_STATE_DO_MORE);
@@ -1944,7 +1944,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
           }
         }
         else if((CURLE_SEND_ERROR == result) &&
-                data->conn->bits.reuse) { 
+                data->conn->bits.reuse) {
           /*
            * In this situation, a connection that we were trying to use
            * may have unexpectedly died.  If possible, send the connection
@@ -1954,7 +1954,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
           followtype follow = FOLLOW_NONE;
           CURLcode drc;
 
-          drc = Curl_retry_request(data->conn, &newurl); 
+          drc = Curl_retry_request(data->conn, &newurl);
           if(drc) {
             /* a failure here pretty much implies an out of memory */
             result = drc;
@@ -1962,7 +1962,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
           }
 
           Curl_posttransfer(data);
-          drc = multi_done(data, result, FALSE); 
+          drc = multi_done(data, result, FALSE);
 
           /* When set to retry the connection, we must to go back to
            * the CONNECT state */
@@ -1994,8 +1994,8 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
         else {
           /* failure detected */
           Curl_posttransfer(data);
-          if(data->conn) 
-            multi_done(data, result, FALSE); 
+          if(data->conn)
+            multi_done(data, result, FALSE);
           stream_error = TRUE;
         }
       }
@@ -2003,12 +2003,12 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
 
     case CURLM_STATE_DOING:
       /* we continue DOING until the DO phase is complete */
-      DEBUGASSERT(data->conn); 
-      result = protocol_doing(data->conn, &dophase_done); 
+      DEBUGASSERT(data->conn);
+      result = protocol_doing(data->conn, &dophase_done);
       if(!result) {
         if(dophase_done) {
           /* after DO, go DO_DONE or DO_MORE */
-          multistate(data, data->conn->bits.do_more? 
+          multistate(data, data->conn->bits.do_more?
                      CURLM_STATE_DO_MORE:
                      CURLM_STATE_DO_DONE);
           rc = CURLM_CALL_MULTI_PERFORM;
@@ -2017,7 +2017,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
       else {
         /* failure detected */
         Curl_posttransfer(data);
-        multi_done(data, result, FALSE); 
+        multi_done(data, result, FALSE);
         stream_error = TRUE;
       }
       break;
@@ -2026,8 +2026,8 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
       /*
        * When we are connected, DO MORE and then go DO_DONE
        */
-      DEBUGASSERT(data->conn); 
-      result = multi_do_more(data->conn, &control); 
+      DEBUGASSERT(data->conn);
+      result = multi_do_more(data->conn, &control);
 
       if(!result) {
         if(control) {
@@ -2045,38 +2045,38 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
       else {
         /* failure detected */
         Curl_posttransfer(data);
-        multi_done(data, result, FALSE); 
+        multi_done(data, result, FALSE);
         stream_error = TRUE;
       }
       break;
 
     case CURLM_STATE_DO_DONE:
-      DEBUGASSERT(data->conn); 
-      if(data->conn->bits.multiplex) 
+      DEBUGASSERT(data->conn);
+      if(data->conn->bits.multiplex)
         /* Check if we can move pending requests to send pipe */
-        process_pending_handles(multi); /*  multiplexed */ 
+        process_pending_handles(multi); /*  multiplexed */
 
       /* Only perform the transfer if there's a good socket to work with.
          Having both BAD is a signal to skip immediately to DONE */
-      if((data->conn->sockfd != CURL_SOCKET_BAD) || 
-         (data->conn->writesockfd != CURL_SOCKET_BAD)) 
-        multistate(data, CURLM_STATE_PERFORM); 
+      if((data->conn->sockfd != CURL_SOCKET_BAD) ||
+         (data->conn->writesockfd != CURL_SOCKET_BAD))
+        multistate(data, CURLM_STATE_PERFORM);
       else {
-#ifndef CURL_DISABLE_FTP 
+#ifndef CURL_DISABLE_FTP
         if(data->state.wildcardmatch &&
-           ((data->conn->handler->flags & PROTOPT_WILDCARD) == 0)) { 
-          data->wildcard.state = CURLWC_DONE; 
+           ((data->conn->handler->flags & PROTOPT_WILDCARD) == 0)) {
+          data->wildcard.state = CURLWC_DONE;
         }
-#endif 
+#endif
         multistate(data, CURLM_STATE_DONE);
       }
       rc = CURLM_CALL_MULTI_PERFORM;
       break;
 
     case CURLM_STATE_TOOFAST: /* limit-rate exceeded in either direction */
-      DEBUGASSERT(data->conn); 
+      DEBUGASSERT(data->conn);
       /* if both rates are within spec, resume transfer */
-      if(Curl_pgrsUpdate(data->conn)) 
+      if(Curl_pgrsUpdate(data->conn))
         result = CURLE_ABORTED_BY_CALLBACK;
       else
         result = Curl_speedcheck(data, *nowp);
@@ -2146,14 +2146,14 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
       }
 
       /* read/write data if it is ready to do so */
-      result = Curl_readwrite(data->conn, data, &done, &comeback); 
+      result = Curl_readwrite(data->conn, data, &done, &comeback);
 
       if(done || (result == CURLE_RECV_ERROR)) {
         /* If CURLE_RECV_ERROR happens early enough, we assume it was a race
          * condition and the server closed the re-used connection exactly when
          * we wanted to use it, so figure out if that is indeed the case.
          */
-        CURLcode ret = Curl_retry_request(data->conn, &newurl); 
+        CURLcode ret = Curl_retry_request(data->conn, &newurl);
         if(!ret)
           retry = (newurl)?TRUE:FALSE;
         else if(!result)
@@ -2167,25 +2167,25 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
         }
       }
       else if((CURLE_HTTP2_STREAM == result) &&
-              Curl_h2_http_1_1_error(data->conn)) { 
-        CURLcode ret = Curl_retry_request(data->conn, &newurl); 
-
-        if(!ret) { 
-          infof(data, "Downgrades to HTTP/1.1!\n"); 
-          data->set.httpversion = CURL_HTTP_VERSION_1_1; 
-          /* clear the error message bit too as we ignore the one we got */ 
-          data->state.errorbuf = FALSE; 
-          if(!newurl) 
-            /* typically for HTTP_1_1_REQUIRED error on first flight */ 
-            newurl = strdup(data->change.url); 
-          /* if we are to retry, set the result to OK and consider the request 
-             as done */ 
-          retry = TRUE; 
+              Curl_h2_http_1_1_error(data->conn)) {
+        CURLcode ret = Curl_retry_request(data->conn, &newurl);
+
+        if(!ret) {
+          infof(data, "Downgrades to HTTP/1.1!\n");
+          data->set.httpversion = CURL_HTTP_VERSION_1_1;
+          /* clear the error message bit too as we ignore the one we got */
+          data->state.errorbuf = FALSE;
+          if(!newurl)
+            /* typically for HTTP_1_1_REQUIRED error on first flight */
+            newurl = strdup(data->change.url);
+          /* if we are to retry, set the result to OK and consider the request
+             as done */
+          retry = TRUE;
           result = CURLE_OK;
           done = TRUE;
         }
-        else 
-          result = ret; 
+        else
+          result = ret;
       }
 
       if(result) {
@@ -2197,12 +2197,12 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
          * happened in the data connection.
          */
 
-        if(!(data->conn->handler->flags & PROTOPT_DUAL) && 
+        if(!(data->conn->handler->flags & PROTOPT_DUAL) &&
            result != CURLE_HTTP2_STREAM)
-          streamclose(data->conn, "Transfer returned error"); 
+          streamclose(data->conn, "Transfer returned error");
 
         Curl_posttransfer(data);
-        multi_done(data, result, TRUE); 
+        multi_done(data, result, TRUE);
       }
       else if(done) {
         followtype follow = FOLLOW_NONE;
@@ -2223,12 +2223,12 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
           }
           else
             follow = FOLLOW_RETRY;
-          (void)multi_done(data, CURLE_OK, FALSE); 
-          /* multi_done() might return CURLE_GOT_NOTHING */ 
-          result = Curl_follow(data, newurl, follow); 
+          (void)multi_done(data, CURLE_OK, FALSE);
+          /* multi_done() might return CURLE_GOT_NOTHING */
+          result = Curl_follow(data, newurl, follow);
           if(!result) {
-            multistate(data, CURLM_STATE_CONNECT); 
-            rc = CURLM_CALL_MULTI_PERFORM; 
+            multistate(data, CURLM_STATE_CONNECT);
+            rc = CURLM_CALL_MULTI_PERFORM;
           }
           free(newurl);
         }
@@ -2245,7 +2245,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
             free(newurl);
             if(result) {
               stream_error = TRUE;
-              result = multi_done(data, result, TRUE); 
+              result = multi_done(data, result, TRUE);
             }
           }
 
@@ -2269,30 +2269,30 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
       /* this state is highly transient, so run another loop after this */
       rc = CURLM_CALL_MULTI_PERFORM;
 
-      if(data->conn) { 
+      if(data->conn) {
         CURLcode res;
 
-        if(data->conn->bits.multiplex) 
+        if(data->conn->bits.multiplex)
           /* Check if we can move pending requests to connection */
-          process_pending_handles(multi); /* multiplexing */ 
+          process_pending_handles(multi); /* multiplexing */
 
         /* post-transfer command */
-        res = multi_done(data, result, FALSE); 
+        res = multi_done(data, result, FALSE);
 
         /* allow a previously set error code take precedence */
         if(!result)
           result = res;
 
         /*
-         * If there are other handles on the connection, multi_done won't set 
-         * conn to NULL.  In such a case, curl_multi_remove_handle() can 
+         * If there are other handles on the connection, multi_done won't set
+         * conn to NULL.  In such a case, curl_multi_remove_handle() can
          * access free'd data, if the connection is free'd and the handle
          * removed before we perform the processing in CURLM_STATE_COMPLETED
          */
         Curl_detach_connnection(data);
       }
 
-#ifndef CURL_DISABLE_FTP 
+#ifndef CURL_DISABLE_FTP
       if(data->state.wildcardmatch) {
         if(data->wildcard.state != CURLWC_DONE) {
           /* if a wildcard is set and we are not ending -> lets start again
@@ -2301,7 +2301,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
           break;
         }
       }
-#endif 
+#endif
       /* after we have DONE what we're supposed to do, go COMPLETED, and
          it doesn't matter what the multi_done() returned! */
       multistate(data, CURLM_STATE_COMPLETED);
@@ -2332,22 +2332,22 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
         /* Check if we can move pending requests to send pipe */
         process_pending_handles(multi); /* connection */
 
-        if(data->conn) { 
+        if(data->conn) {
           if(stream_error) {
             /* Don't attempt to send data over a connection that timed out */
             bool dead_connection = result == CURLE_OPERATION_TIMEDOUT;
-            struct connectdata *conn = data->conn; 
+            struct connectdata *conn = data->conn;
 
-            /* This is where we make sure that the conn pointer is reset. 
+            /* This is where we make sure that the conn pointer is reset.
                We don't have to do this in every case block above where a
                failure is detected */
             Curl_detach_connnection(data);
- 
+
             /* remove connection from cache */
             Curl_conncache_remove_conn(data, conn, TRUE);
 
-            /* disconnect properly */ 
-            Curl_disconnect(data, conn, dead_connection); 
+            /* disconnect properly */
+            Curl_disconnect(data, conn, dead_connection);
           }
         }
         else if(data->mstate == CURLM_STATE_CONNECT) {
@@ -2359,11 +2359,11 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
         rc = CURLM_CALL_MULTI_PERFORM;
       }
       /* if there's still a connection to use, call the progress function */
-      else if(data->conn && Curl_pgrsUpdate(data->conn)) { 
+      else if(data->conn && Curl_pgrsUpdate(data->conn)) {
         /* aborted due to progress callback return code must close the
            connection */
         result = CURLE_ABORTED_BY_CALLBACK;
-        streamclose(data->conn, "Aborted by callback"); 
+        streamclose(data->conn, "Aborted by callback");
 
         /* if not yet in DONE state, go there, otherwise COMPLETED */
         multistate(data, (data->mstate < CURLM_STATE_DONE)?
@@ -2386,7 +2386,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
         msg->extmsg.data.result = result;
 
         rc = multi_addmsg(multi, msg);
-        DEBUGASSERT(!data->conn); 
+        DEBUGASSERT(!data->conn);
       }
       multistate(data, CURLM_STATE_MSGSENT);
     }
@@ -2446,7 +2446,7 @@ CURLMcode curl_multi_perform(struct Curl_multi *multi, int *running_handles)
   *running_handles = multi->num_alive;
 
   if(CURLM_OK >= returncode)
-    Curl_update_timer(multi); 
+    Curl_update_timer(multi);
 
   return returncode;
 }
@@ -2466,9 +2466,9 @@ CURLMcode curl_multi_cleanup(struct Curl_multi *multi)
     data = multi->easyp;
     while(data) {
       nextdata = data->next;
-      if(!data->state.done && data->conn) 
+      if(!data->state.done && data->conn)
         /* if DONE was never called for this handle */
-        (void)multi_done(data, CURLE_OK, TRUE); 
+        (void)multi_done(data, CURLE_OK, TRUE);
       if(data->dns.hostcachetype == HCACHE_MULTI) {
         /* clear out the usage of the shared DNS cache */
         Curl_hostcache_clean(data, data->dns.hostcache);
@@ -2561,14 +2561,14 @@ static CURLMcode singlesocket(struct Curl_multi *multi,
   curl_socket_t s;
   int num;
   unsigned int curraction;
-  int actions[MAX_SOCKSPEREASYHANDLE]; 
+  int actions[MAX_SOCKSPEREASYHANDLE];
 
   for(i = 0; i< MAX_SOCKSPEREASYHANDLE; i++)
     socks[i] = CURL_SOCKET_BAD;
 
   /* Fill in the 'current' struct with the state as it is now: what sockets to
      supervise and for what actions */
-  curraction = multi_getsock(data, socks); 
+  curraction = multi_getsock(data, socks);
 
   /* We have 0 .. N sockets already and we get to know about the 0 .. M
      sockets we should have from now on. Detect the differences, remove no
@@ -2578,10 +2578,10 @@ static CURLMcode singlesocket(struct Curl_multi *multi,
   for(i = 0; (i< MAX_SOCKSPEREASYHANDLE) &&
         (curraction & (GETSOCK_READSOCK(i) | GETSOCK_WRITESOCK(i)));
       i++) {
-    unsigned int action = CURL_POLL_NONE; 
-    unsigned int prevaction = 0; 
-    unsigned int comboaction; 
-    bool sincebefore = FALSE; 
+    unsigned int action = CURL_POLL_NONE;
+    unsigned int prevaction = 0;
+    unsigned int comboaction;
+    bool sincebefore = FALSE;
 
     s = socks[i];
 
@@ -2593,63 +2593,63 @@ static CURLMcode singlesocket(struct Curl_multi *multi,
     if(curraction & GETSOCK_WRITESOCK(i))
       action |= CURL_POLL_OUT;
 
-    actions[i] = action; 
+    actions[i] = action;
     if(entry) {
-      /* check if new for this transfer */ 
-      int j; 
-      for(j = 0; j< data->numsocks; j++) { 
-        if(s == data->sockets[j]) { 
-          prevaction = data->actions[j]; 
-          sincebefore = TRUE; 
-          break; 
-        } 
-      } 
+      /* check if new for this transfer */
+      int j;
+      for(j = 0; j< data->numsocks; j++) {
+        if(s == data->sockets[j]) {
+          prevaction = data->actions[j];
+          sincebefore = TRUE;
+          break;
+        }
+      }
     }
     else {
-      /* this is a socket we didn't have before, add it to the hash! */ 
-      entry = sh_addentry(&multi->sockhash, s); 
+      /* this is a socket we didn't have before, add it to the hash! */
+      entry = sh_addentry(&multi->sockhash, s);
       if(!entry)
         /* fatal */
         return CURLM_OUT_OF_MEMORY;
     }
-    if(sincebefore && (prevaction != action)) { 
-      /* Socket was used already, but different action now */ 
-      if(prevaction & CURL_POLL_IN) 
-        entry->readers--; 
-      if(prevaction & CURL_POLL_OUT) 
-        entry->writers--; 
-      if(action & CURL_POLL_IN) 
-        entry->readers++; 
-      if(action & CURL_POLL_OUT) 
-        entry->writers++; 
-    } 
-    else if(!sincebefore) { 
-      /* a new user */ 
-      entry->users++; 
-      if(action & CURL_POLL_IN) 
-        entry->readers++; 
-      if(action & CURL_POLL_OUT) 
-        entry->writers++; 
-
-      /* add 'data' to the transfer hash on this socket! */ 
-      if(!Curl_hash_add(&entry->transfers, (char *)&data, /* hash key */ 
-                        sizeof(struct Curl_easy *), data)) 
-        return CURLM_OUT_OF_MEMORY; 
-    } 
- 
-    comboaction = (entry->writers? CURL_POLL_OUT : 0) | 
-      (entry->readers ? CURL_POLL_IN : 0); 
- 
-    /* socket existed before and has the same action set as before */ 
-    if(sincebefore && (entry->action == comboaction)) 
-      /* same, continue */ 
-      continue; 
- 
+    if(sincebefore && (prevaction != action)) {
+      /* Socket was used already, but different action now */
+      if(prevaction & CURL_POLL_IN)
+        entry->readers--;
+      if(prevaction & CURL_POLL_OUT)
+        entry->writers--;
+      if(action & CURL_POLL_IN)
+        entry->readers++;
+      if(action & CURL_POLL_OUT)
+        entry->writers++;
+    }
+    else if(!sincebefore) {
+      /* a new user */
+      entry->users++;
+      if(action & CURL_POLL_IN)
+        entry->readers++;
+      if(action & CURL_POLL_OUT)
+        entry->writers++;
+
+      /* add 'data' to the transfer hash on this socket! */
+      if(!Curl_hash_add(&entry->transfers, (char *)&data, /* hash key */
+                        sizeof(struct Curl_easy *), data))
+        return CURLM_OUT_OF_MEMORY;
+    }
+
+    comboaction = (entry->writers? CURL_POLL_OUT : 0) |
+      (entry->readers ? CURL_POLL_IN : 0);
+
+    /* socket existed before and has the same action set as before */
+    if(sincebefore && (entry->action == comboaction))
+      /* same, continue */
+      continue;
+
     if(multi->socket_cb)
-      multi->socket_cb(data, s, comboaction, multi->socket_userp, 
+      multi->socket_cb(data, s, comboaction, multi->socket_userp,
                        entry->socketp);
 
-    entry->action = comboaction; /* store the current action state */ 
+    entry->action = comboaction; /* store the current action state */
   }
 
   num = i; /* number of sockets */
@@ -2658,48 +2658,48 @@ static CURLMcode singlesocket(struct Curl_multi *multi,
      make sure to detect sockets that are removed */
   for(i = 0; i< data->numsocks; i++) {
     int j;
-    bool stillused = FALSE; 
+    bool stillused = FALSE;
     s = data->sockets[i];
-    for(j = 0; j < num; j++) { 
+    for(j = 0; j < num; j++) {
       if(s == socks[j]) {
         /* this is still supervised */
-        stillused = TRUE; 
+        stillused = TRUE;
         break;
       }
     }
-    if(stillused) 
-      continue; 
+    if(stillused)
+      continue;
 
     entry = sh_getentry(&multi->sockhash, s);
-    /* if this is NULL here, the socket has been closed and notified so 
-       already by Curl_multi_closed() */ 
+    /* if this is NULL here, the socket has been closed and notified so
+       already by Curl_multi_closed() */
     if(entry) {
-      int oldactions = data->actions[i]; 
-      /* this socket has been removed. Decrease user count */ 
-      entry->users--; 
-      if(oldactions & CURL_POLL_OUT) 
-        entry->writers--; 
-      if(oldactions & CURL_POLL_IN) 
-        entry->readers--; 
-      if(!entry->users) { 
+      int oldactions = data->actions[i];
+      /* this socket has been removed. Decrease user count */
+      entry->users--;
+      if(oldactions & CURL_POLL_OUT)
+        entry->writers--;
+      if(oldactions & CURL_POLL_IN)
+        entry->readers--;
+      if(!entry->users) {
         if(multi->socket_cb)
-          multi->socket_cb(data, s, CURL_POLL_REMOVE, 
+          multi->socket_cb(data, s, CURL_POLL_REMOVE,
                            multi->socket_userp,
                            entry->socketp);
-        sh_delentry(entry, &multi->sockhash, s); 
+        sh_delentry(entry, &multi->sockhash, s);
+      }
+      else {
+        /* still users, but remove this handle as a user of this socket */
+        if(Curl_hash_delete(&entry->transfers, (char *)&data,
+                            sizeof(struct Curl_easy *))) {
+          DEBUGASSERT(NULL);
+        }
       }
-      else { 
-        /* still users, but remove this handle as a user of this socket */ 
-        if(Curl_hash_delete(&entry->transfers, (char *)&data, 
-                            sizeof(struct Curl_easy *))) { 
-          DEBUGASSERT(NULL); 
-        } 
-      } 
-    } 
+    }
   } /* for loop over numsocks */
 
   memcpy(data->sockets, socks, num*sizeof(curl_socket_t));
-  memcpy(data->actions, actions, num*sizeof(int)); 
+  memcpy(data->actions, actions, num*sizeof(int));
   data->numsocks = num;
   return CURLM_OK;
 }
@@ -2737,7 +2737,7 @@ void Curl_multi_closed(struct Curl_easy *data, curl_socket_t s)
                            entry->socketp);
 
         /* now remove it from the socket hash */
-        sh_delentry(entry, &multi->sockhash, s); 
+        sh_delentry(entry, &multi->sockhash, s);
       }
     }
   }
@@ -2841,19 +2841,19 @@ static CURLMcode multi_socket(struct Curl_multi *multi,
       struct Curl_hash_iterator iter;
       struct Curl_hash_element *he;
 
-      /* the socket can be shared by many transfers, iterate */ 
-      Curl_hash_start_iterate(&entry->transfers, &iter); 
-      for(he = Curl_hash_next_element(&iter); he; 
-          he = Curl_hash_next_element(&iter)) { 
-        data = (struct Curl_easy *)he->ptr; 
-        DEBUGASSERT(data); 
-        DEBUGASSERT(data->magic == CURLEASY_MAGIC_NUMBER); 
+      /* the socket can be shared by many transfers, iterate */
+      Curl_hash_start_iterate(&entry->transfers, &iter);
+      for(he = Curl_hash_next_element(&iter); he;
+          he = Curl_hash_next_element(&iter)) {
+        data = (struct Curl_easy *)he->ptr;
+        DEBUGASSERT(data);
+        DEBUGASSERT(data->magic == CURLEASY_MAGIC_NUMBER);
 
-        if(data->conn && !(data->conn->handler->flags & PROTOPT_DIRLOCK)) 
-          /* set socket event bitmask if they're not locked */ 
-          data->conn->cselect_bits = ev_bitmask; 
+        if(data->conn && !(data->conn->handler->flags & PROTOPT_DIRLOCK))
+          /* set socket event bitmask if they're not locked */
+          data->conn->cselect_bits = ev_bitmask;
 
-        Curl_expire(data, 0, EXPIRE_RUN_NOW); 
+        Curl_expire(data, 0, EXPIRE_RUN_NOW);
       }
 
       /* Now we fall-through and do the timer-based stuff, since we don't want
@@ -2868,10 +2868,10 @@ static CURLMcode multi_socket(struct Curl_multi *multi,
   }
   else {
     /* Asked to run due to time-out. Clear the 'lastcall' variable to force
-       Curl_update_timer() to trigger a callback to the app again even if the 
-       same timeout is still the one to run after this call. That handles the 
-       case when the application asks libcurl to run the timeout 
-       prematurely. */ 
+       Curl_update_timer() to trigger a callback to the app again even if the
+       same timeout is still the one to run after this call. That handles the
+       case when the application asks libcurl to run the timeout
+       prematurely. */
     memset(&multi->timer_lastcall, 0, sizeof(multi->timer_lastcall));
   }
 
@@ -2942,7 +2942,7 @@ CURLMcode curl_multi_setopt(struct Curl_multi *multi,
     multi->push_userp = va_arg(param, void *);
     break;
   case CURLMOPT_PIPELINING:
-    multi->multiplexing = va_arg(param, long) & CURLPIPE_MULTIPLEX; 
+    multi->multiplexing = va_arg(param, long) & CURLPIPE_MULTIPLEX;
     break;
   case CURLMOPT_TIMERFUNCTION:
     multi->timer_cb = va_arg(param, curl_multi_timer_callback);
@@ -2956,10 +2956,10 @@ CURLMcode curl_multi_setopt(struct Curl_multi *multi,
   case CURLMOPT_MAX_HOST_CONNECTIONS:
     multi->max_host_connections = va_arg(param, long);
     break;
-  case CURLMOPT_MAX_TOTAL_CONNECTIONS: 
-    multi->max_total_connections = va_arg(param, long); 
-    break; 
-    /* options formerly used for pipelining */ 
+  case CURLMOPT_MAX_TOTAL_CONNECTIONS:
+    multi->max_total_connections = va_arg(param, long);
+    break;
+    /* options formerly used for pipelining */
   case CURLMOPT_MAX_PIPELINE_LENGTH:
     break;
   case CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE:
@@ -2997,7 +2997,7 @@ CURLMcode curl_multi_socket(struct Curl_multi *multi, curl_socket_t s,
     return CURLM_RECURSIVE_API_CALL;
   result = multi_socket(multi, FALSE, s, 0, running_handles);
   if(CURLM_OK >= result)
-    Curl_update_timer(multi); 
+    Curl_update_timer(multi);
   return result;
 }
 
@@ -3009,7 +3009,7 @@ CURLMcode curl_multi_socket_action(struct Curl_multi *multi, curl_socket_t s,
     return CURLM_RECURSIVE_API_CALL;
   result = multi_socket(multi, FALSE, s, ev_bitmask, running_handles);
   if(CURLM_OK >= result)
-    Curl_update_timer(multi); 
+    Curl_update_timer(multi);
   return result;
 }
 
@@ -3020,7 +3020,7 @@ CURLMcode curl_multi_socket_all(struct Curl_multi *multi, int *running_handles)
     return CURLM_RECURSIVE_API_CALL;
   result = multi_socket(multi, TRUE, CURL_SOCKET_BAD, 0, running_handles);
   if(CURLM_OK >= result)
-    Curl_update_timer(multi); 
+    Curl_update_timer(multi);
   return result;
 }
 
@@ -3080,14 +3080,14 @@ CURLMcode curl_multi_timeout(struct Curl_multi *multi,
  * Tell the application it should update its timers, if it subscribes to the
  * update timer callback.
  */
-void Curl_update_timer(struct Curl_multi *multi) 
+void Curl_update_timer(struct Curl_multi *multi)
 {
   long timeout_ms;
 
   if(!multi->timer_cb)
-    return; 
+    return;
   if(multi_timeout(multi, &timeout_ms)) {
-    return; 
+    return;
   }
   if(timeout_ms < 0) {
     static const struct curltime none = {0, 0};
@@ -3095,10 +3095,10 @@ void Curl_update_timer(struct Curl_multi *multi)
       multi->timer_lastcall = none;
       /* there's no timeout now but there was one previously, tell the app to
          disable it */
-      multi->timer_cb(multi, -1, multi->timer_userp); 
-      return; 
+      multi->timer_cb(multi, -1, multi->timer_userp);
+      return;
     }
-    return; 
+    return;
   }
 
   /* When multi_timeout() is done, multi->timetree points to the node with the
@@ -3106,11 +3106,11 @@ void Curl_update_timer(struct Curl_multi *multi)
    * if this is the same (fixed) time as we got in a previous call and then
    * avoid calling the callback again. */
   if(Curl_splaycomparekeys(multi->timetree->key, multi->timer_lastcall) == 0)
-    return; 
+    return;
 
   multi->timer_lastcall = multi->timetree->key;
 
-  multi->timer_cb(multi, timeout_ms, multi->timer_userp); 
+  multi->timer_cb(multi, timeout_ms, multi->timer_userp);
 }
 
 /*
@@ -3187,7 +3187,7 @@ multi_addtimeout(struct Curl_easy *data,
  *
  * Expire replaces a former timeout using the same id if already set.
  */
-void Curl_expire(struct Curl_easy *data, timediff_t milli, expire_id id) 
+void Curl_expire(struct Curl_easy *data, timediff_t milli, expire_id id)
 {
   struct Curl_multi *multi = data->multi;
   struct curltime *nowp = &data->state.expiretime;
@@ -3201,7 +3201,7 @@ void Curl_expire(struct Curl_easy *data, timediff_t milli, expire_id id)
   DEBUGASSERT(id < EXPIRE_LAST);
 
   set = Curl_now();
-  set.tv_sec += (time_t)(milli/1000); /* might be a 64 to 32 bit conversion */ 
+  set.tv_sec += (time_t)(milli/1000); /* might be a 64 to 32 bit conversion */
   set.tv_usec += (unsigned int)(milli%1000)*1000;
 
   if(set.tv_usec >= 1000000) {
@@ -3289,7 +3289,7 @@ void Curl_expire_clear(struct Curl_easy *data)
     }
 
 #ifdef DEBUGBUILD
-    infof(data, "Expire cleared (transfer %p)\n", data); 
+    infof(data, "Expire cleared (transfer %p)\n", data);
 #endif
     nowp->tv_sec = 0;
     nowp->tv_usec = 0;
@@ -3327,20 +3327,20 @@ size_t Curl_multi_max_total_connections(struct Curl_multi *multi)
   return multi ? multi->max_total_connections : 0;
 }
 
-/* 
- * When information about a connection has appeared, call this! 
- */ 
+/*
+ * When information about a connection has appeared, call this!
+ */
 
-void Curl_multiuse_state(struct connectdata *conn, 
-                         int bundlestate) /* use BUNDLE_* defines */ 
+void Curl_multiuse_state(struct connectdata *conn,
+                         int bundlestate) /* use BUNDLE_* defines */
 {
-  DEBUGASSERT(conn); 
-  DEBUGASSERT(conn->bundle); 
-  DEBUGASSERT(conn->data); 
-  DEBUGASSERT(conn->data->multi); 
+  DEBUGASSERT(conn);
+  DEBUGASSERT(conn->bundle);
+  DEBUGASSERT(conn->data);
+  DEBUGASSERT(conn->data->multi);
 
-  conn->bundle->multiuse = bundlestate; 
-  process_pending_handles(conn->data->multi); 
+  conn->bundle->multiuse = bundlestate;
+  process_pending_handles(conn->data->multi);
 }
 
 static void process_pending_handles(struct Curl_multi *multi)
@@ -3358,9 +3358,9 @@ static void process_pending_handles(struct Curl_multi *multi)
 
     /* Make sure that the handle will be processed soonish. */
     Curl_expire(data, 0, EXPIRE_RUN_NOW);
- 
-    /* mark this as having been in the pending queue */ 
-    data->state.previouslypending = TRUE; 
+
+    /* mark this as having been in the pending queue */
+    data->state.previouslypending = TRUE;
   }
 }
 
@@ -3404,8 +3404,8 @@ void Curl_multi_dump(struct Curl_multi *multi)
           continue;
         }
         fprintf(stderr, "[%s %s] ",
-                (entry->action&CURL_POLL_IN)?"RECVING":"", 
-                (entry->action&CURL_POLL_OUT)?"SENDING":""); 
+                (entry->action&CURL_POLL_IN)?"RECVING":"",
+                (entry->action&CURL_POLL_OUT)?"SENDING":"");
       }
       if(data->numsocks)
         fprintf(stderr, "\n");