Restoring authorship annotation for <[email protected]>. Commit 1 of 2.

1 files changed, 349 insertions, 349 deletions

diff --git a/contrib/libs/curl/lib/multi.c b/contrib/libs/curl/lib/multi.c
index f1c9e4dbfba..08c66861578 100644
--- a/contrib/libs/curl/lib/multi.c
+++ b/contrib/libs/curl/lib/multi.c
@@ -5,11 +5,11 @@
  *                            | (__| |_| |  _ <| |___
  *                             \___|\___/|_| \_\_____|
  *
- * Copyright (C) 1998 - 2020, Daniel Stenberg, <[email protected]>, et al.
+ * Copyright (C) 1998 - 2020, Daniel Stenberg, <[email protected]>, 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
@@ -46,8 +46,8 @@
 #include "connect.h"
 #include "http_proxy.h"
 #include "http2.h"
-#include "socketpair.h"
-#include "socks.h"
+#include "socketpair.h" 
+#include "socks.h" 
 /* The last 3 #include files should be in this order */
 #include "curl_printf.h"
 #include "curl_memory.h"
@@ -111,7 +111,7 @@ static void Curl_init_completed(struct Curl_easy *data)
 
   /* Important: reset the conn pointer so that we don't point to memory
      that could be freed anytime */
-  Curl_detach_connnection(data);
+  Curl_detach_connnection(data); 
   Curl_expire_clear(data); /* stop all timers */
 }
 
@@ -168,11 +168,11 @@ static void mstate(struct Curl_easy *data, CURLMstate state
   }
 #endif
 
-  if(state == CURLM_STATE_COMPLETED) {
+  if(state == CURLM_STATE_COMPLETED) { 
     /* changing to COMPLETED means there's one less easy handle 'alive' */
-    DEBUGASSERT(data->multi->num_alive > 0);
+    DEBUGASSERT(data->multi->num_alive > 0); 
     data->multi->num_alive--;
-  }
+  } 
 
   /* if this state has an init-function, run it */
   if(finit[state])
@@ -190,7 +190,7 @@ static void mstate(struct Curl_easy *data, CURLMstate state
  */
 
 struct Curl_sh_entry {
-  struct Curl_hash transfers; /* hash of transfers using this socket */
+  struct Curl_hash transfers; /* hash of transfers using this socket */ 
   unsigned int action;  /* what combined action READ/WRITE this socket waits
                            for */
   void *socketp; /* settable by users with curl_multi_assign() */
@@ -204,7 +204,7 @@ struct Curl_sh_entry {
 #define SH_WRITE 2
 
 /* look up a given socket in the socket hash, skip invalid sockets */
-static struct Curl_sh_entry *sh_getentry(struct Curl_hash *sh,
+static struct Curl_sh_entry *sh_getentry(struct Curl_hash *sh, 
                                          curl_socket_t s)
 {
   if(s != CURL_SOCKET_BAD) {
@@ -238,7 +238,7 @@ static void trhash_dtor(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,
+static struct Curl_sh_entry *sh_addentry(struct Curl_hash *sh, 
                                          curl_socket_t s)
 {
   struct Curl_sh_entry *there = sh_getentry(sh, s);
@@ -262,7 +262,7 @@ static struct Curl_sh_entry *sh_addentry(struct Curl_hash *sh,
 
   /* make/add new hash entry */
   if(!Curl_hash_add(sh, (char *)&s, sizeof(curl_socket_t), check)) {
-    Curl_hash_destroy(&check->transfers);
+    Curl_hash_destroy(&check->transfers); 
     free(check);
     return NULL; /* major failure */
   }
@@ -273,7 +273,7 @@ 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,
-                        struct Curl_hash *sh, curl_socket_t s)
+                        struct Curl_hash *sh, curl_socket_t s) 
 {
   Curl_hash_destroy(&entry->transfers);
 
@@ -325,7 +325,7 @@ static size_t hash_fd(void *key, size_t key_length, size_t slots_num)
  * per call."
  *
  */
-static int sh_init(struct Curl_hash *hash, int hashsize)
+static int sh_init(struct Curl_hash *hash, int hashsize) 
 {
   return Curl_hash_init(hash, hashsize, hash_fd, fd_key_compare,
                         sh_freeentry);
@@ -367,27 +367,27 @@ struct Curl_multi *Curl_multi_handle(int hashsize, /* socket hash */
   Curl_llist_init(&multi->msglist, NULL);
   Curl_llist_init(&multi->pending, NULL);
 
-  multi->multiplexing = TRUE;
+  multi->multiplexing = TRUE; 
 
   /* -1 means it not set by user, use the default value */
   multi->maxconnects = -1;
-  multi->max_concurrent_streams = 100;
-  multi->ipv6_works = Curl_ipv6works(NULL);
-
-#ifdef ENABLE_WAKEUP
-  if(Curl_socketpair(AF_UNIX, SOCK_STREAM, 0, multi->wakeup_pair) < 0) {
-    multi->wakeup_pair[0] = CURL_SOCKET_BAD;
-    multi->wakeup_pair[1] = CURL_SOCKET_BAD;
-  }
-  else if(curlx_nonblock(multi->wakeup_pair[0], TRUE) < 0 ||
-          curlx_nonblock(multi->wakeup_pair[1], TRUE) < 0) {
-    sclose(multi->wakeup_pair[0]);
-    sclose(multi->wakeup_pair[1]);
-    multi->wakeup_pair[0] = CURL_SOCKET_BAD;
-    multi->wakeup_pair[1] = CURL_SOCKET_BAD;
-  }
-#endif
-
+  multi->max_concurrent_streams = 100; 
+  multi->ipv6_works = Curl_ipv6works(NULL); 
+ 
+#ifdef ENABLE_WAKEUP 
+  if(Curl_socketpair(AF_UNIX, SOCK_STREAM, 0, multi->wakeup_pair) < 0) { 
+    multi->wakeup_pair[0] = CURL_SOCKET_BAD; 
+    multi->wakeup_pair[1] = CURL_SOCKET_BAD; 
+  } 
+  else if(curlx_nonblock(multi->wakeup_pair[0], TRUE) < 0 || 
+          curlx_nonblock(multi->wakeup_pair[1], TRUE) < 0) { 
+    sclose(multi->wakeup_pair[0]); 
+    sclose(multi->wakeup_pair[1]); 
+    multi->wakeup_pair[0] = CURL_SOCKET_BAD; 
+    multi->wakeup_pair[1] = CURL_SOCKET_BAD; 
+  } 
+#endif 
+ 
   return multi;
 
   error:
@@ -455,7 +455,7 @@ CURLMcode curl_multi_add_handle(struct Curl_multi *multi,
     data->state.conn_cache = &data->share->conn_cache;
   else
     data->state.conn_cache = &multi->conn_cache;
-  data->state.lastconnect_id = -1;
+  data->state.lastconnect_id = -1; 
 
 #ifdef USE_LIBPSL
   /* Do the same for PSL. */
@@ -508,7 +508,7 @@ CURLMcode curl_multi_add_handle(struct Curl_multi *multi,
      easy handle is added */
   memset(&multi->timer_lastcall, 0, sizeof(multi->timer_lastcall));
 
-  CONNCACHE_LOCK(data);
+  CONNCACHE_LOCK(data); 
   /* The closure handle only ever has default timeouts set. To improve the
      state somewhat we clone the timeouts from each added handle so that the
      closure handle always has the same timeouts as the most recently added
@@ -518,7 +518,7 @@ CURLMcode curl_multi_add_handle(struct Curl_multi *multi,
     data->set.server_response_timeout;
   data->state.conn_cache->closure_handle->set.no_signal =
     data->set.no_signal;
-  CONNCACHE_UNLOCK(data);
+  CONNCACHE_UNLOCK(data); 
 
   Curl_update_timer(multi);
   return CURLM_OK;
@@ -555,8 +555,8 @@ static CURLcode multi_done(struct Curl_easy *data,
     /* Stop if multi_done() has already been called */
     return CURLE_OK;
 
-  conn->data = data; /* ensure the connection uses this transfer now */
-
+  conn->data = data; /* ensure the connection uses this transfer now */ 
+ 
   /* Cancel the resolver (but not dns_entry yet). We used to call
      Curl_resolver_kill here but that blocks waiting for incomplete resolve
      threads (eg getaddrinfo has not returned), which may take a while. */
@@ -595,20 +595,20 @@ static CURLcode multi_done(struct Curl_easy *data,
 
   process_pending_handles(data->multi); /* connection / multiplex */
 
-  CONNCACHE_LOCK(data);
-  Curl_detach_connnection(data);
+  CONNCACHE_LOCK(data); 
+  Curl_detach_connnection(data); 
   if(CONN_INUSE(conn)) {
-    /* Stop if still used. */
+    /* 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);
+    CONNCACHE_UNLOCK(data); 
     DEBUGF(infof(data, "Connection still in use %zu, "
                  "no more multi_done now!\n",
                  conn->easyq.size));
     return CURLE_OK;
   }
-  conn->data = NULL; /* the connection now has no owner */
+  conn->data = NULL; /* the connection now has no owner */ 
   data->state.done = TRUE; /* called just now! */
 
   if(conn->dns_entry) {
@@ -621,7 +621,7 @@ static CURLcode multi_done(struct Curl_easy *data,
   /* if the transfer was completed in a paused state there can be buffered
      data left to free */
   for(i = 0; i < data->state.tempcount; i++) {
-    Curl_dyn_free(&data->state.tempwrite[i].b);
+    Curl_dyn_free(&data->state.tempwrite[i].b); 
   }
   data->state.tempcount = 0;
 
@@ -651,11 +651,11 @@ static CURLcode multi_done(struct Curl_easy *data,
 #endif
      ) || conn->bits.close
        || (premature && !(conn->handler->flags & PROTOPT_STREAM))) {
-    CURLcode res2;
-    connclose(conn, "disconnecting");
-    Curl_conncache_remove_conn(data, conn, FALSE);
-    CONNCACHE_UNLOCK(data);
-    res2 = Curl_disconnect(data, conn, premature);
+    CURLcode res2; 
+    connclose(conn, "disconnecting"); 
+    Curl_conncache_remove_conn(data, conn, FALSE); 
+    CONNCACHE_UNLOCK(data); 
+    res2 = Curl_disconnect(data, conn, premature); 
 
     /* If we had an error already, make sure we return that one. But
        if we got a new error, return that. */
@@ -664,61 +664,61 @@ static CURLcode multi_done(struct Curl_easy *data,
   }
   else {
     char buffer[256];
-    const char *host =
-#ifndef CURL_DISABLE_PROXY
-      conn->bits.socksproxy ?
-      conn->socks_proxy.host.dispname :
-      conn->bits.httpproxy ? conn->http_proxy.host.dispname :
-#endif
-      conn->bits.conn_to_host ? conn->conn_to_host.dispname :
-      conn->host.dispname;
+    const char *host = 
+#ifndef CURL_DISABLE_PROXY 
+      conn->bits.socksproxy ? 
+      conn->socks_proxy.host.dispname : 
+      conn->bits.httpproxy ? conn->http_proxy.host.dispname : 
+#endif 
+      conn->bits.conn_to_host ? conn->conn_to_host.dispname : 
+      conn->host.dispname; 
     /* create string before returning the connection */
     msnprintf(buffer, sizeof(buffer),
               "Connection #%ld to host %s left intact",
-              conn->connection_id, host);
+              conn->connection_id, host); 
     /* the connection is no longer in use by this transfer */
-    CONNCACHE_UNLOCK(data);
-    if(Curl_conncache_return_conn(data, conn)) {
+    CONNCACHE_UNLOCK(data); 
+    if(Curl_conncache_return_conn(data, conn)) { 
       /* remember the most recently used connection */
-      data->state.lastconnect_id = conn->connection_id;
+      data->state.lastconnect_id = conn->connection_id; 
       infof(data, "%s\n", buffer);
     }
     else
-      data->state.lastconnect_id = -1;
+      data->state.lastconnect_id = -1; 
   }
 
-  Curl_safefree(data->state.buffer);
+  Curl_safefree(data->state.buffer); 
   Curl_free_request_state(data);
   return result;
 }
 
-static int close_connect_only(struct connectdata *conn, void *param)
-{
-  struct Curl_easy *data = param;
-
-  if(data->state.lastconnect_id != conn->connection_id)
-    return 0;
-
-  if(conn->data != data)
-    return 1;
-  conn->data = NULL;
-
-  if(!conn->bits.connect_only)
-    return 1;
-
-  connclose(conn, "Removing connect-only easy handle");
-  conn->bits.connect_only = FALSE;
-
-  return 1;
-}
-
+static int close_connect_only(struct connectdata *conn, void *param) 
+{ 
+  struct Curl_easy *data = param; 
+ 
+  if(data->state.lastconnect_id != conn->connection_id) 
+    return 0; 
+ 
+  if(conn->data != data) 
+    return 1; 
+  conn->data = NULL; 
+ 
+  if(!conn->bits.connect_only) 
+    return 1; 
+ 
+  connclose(conn, "Removing connect-only easy handle"); 
+  conn->bits.connect_only = FALSE; 
+ 
+  return 1; 
+} 
+ 
 CURLMcode curl_multi_remove_handle(struct Curl_multi *multi,
                                    struct Curl_easy *data)
 {
   struct Curl_easy *easy = data;
   bool premature;
   bool easy_owns_conn;
-  struct Curl_llist_element *e;
+  struct Curl_llist_element *e; 
 
   /* First, make some basic checks that the CURLM handle is a good handle */
   if(!GOOD_MULTI_HANDLE(multi))
@@ -732,10 +732,10 @@ CURLMcode curl_multi_remove_handle(struct Curl_multi *multi,
   if(!data->multi)
     return CURLM_OK; /* it is already removed so let's say it is fine! */
 
-  /* Prevent users from trying to remove an easy handle from the wrong multi */
-  if(data->multi != multi)
-    return CURLM_BAD_EASY_HANDLE;
-
+  /* Prevent users from trying to remove an easy handle from the wrong multi */ 
+  if(data->multi != multi) 
+    return CURLM_BAD_EASY_HANDLE; 
+ 
   if(multi->in_callback)
     return CURLM_RECURSIVE_API_CALL;
 
@@ -767,8 +767,8 @@ CURLMcode curl_multi_remove_handle(struct Curl_multi *multi,
        we don't leave a half-baked one around */
     if(easy_owns_conn) {
 
-      /* multi_done() clears the association between the easy handle and the
-         connection.
+      /* multi_done() clears the association between the easy handle and the 
+         connection. 
 
          Note that this ignores the return code simply because there's
          nothing really useful to do with it anyway! */
@@ -776,11 +776,11 @@ CURLMcode curl_multi_remove_handle(struct Curl_multi *multi,
     }
   }
 
-  /* The timer must be shut down before data->multi is set to NULL, else the
-     timenode will remain in the splay tree after curl_easy_cleanup is
-     called. Do it after multi_done() in case that sets another time! */
-  Curl_expire_clear(data);
-
+  /* The timer must be shut down before data->multi is set to NULL, else the 
+     timenode will remain in the splay tree after curl_easy_cleanup is 
+     called. Do it after multi_done() in case that sets another time! */ 
+  Curl_expire_clear(data); 
+ 
   if(data->connect_queue.ptr)
     /* the handle was in the pending list waiting for an available connection,
        so go ahead and remove it */
@@ -806,12 +806,12 @@ CURLMcode curl_multi_remove_handle(struct Curl_multi *multi,
                                 vanish with this handle */
 
   /* Remove the association between the connection and the handle */
-  Curl_detach_connnection(data);
-
-  if(data->state.lastconnect_id != -1) {
-    /* Mark any connect-only connection for closure */
-    Curl_conncache_foreach(data, data->state.conn_cache,
-                           data, &close_connect_only);
+  Curl_detach_connnection(data); 
+ 
+  if(data->state.lastconnect_id != -1) { 
+    /* Mark any connect-only connection for closure */ 
+    Curl_conncache_foreach(data, data->state.conn_cache, 
+                           data, &close_connect_only); 
   }
 
 #ifdef USE_LIBPSL
@@ -820,10 +820,10 @@ CURLMcode curl_multi_remove_handle(struct Curl_multi *multi,
     data->psl = NULL;
 #endif
 
-  /* as this was using a shared connection cache we clear the pointer to that
-     since we're not part of that multi handle anymore */
-  data->state.conn_cache = NULL;
-
+  /* as this was using a shared connection cache we clear the pointer to that 
+     since we're not part of that multi handle anymore */ 
+  data->state.conn_cache = NULL; 
+ 
   data->multi = NULL; /* clear the association to this multi handle */
 
   /* make sure there's no pending message in the queue sent from this easy
@@ -865,13 +865,13 @@ bool Curl_multiplex_wanted(const struct Curl_multi *multi)
   return (multi && (multi->multiplexing));
 }
 
-/*
- * Curl_detach_connnection() removes the given transfer from the connection.
- *
- * This is the only function that should clear data->conn. This will
- * occasionally be called with the data->conn pointer already cleared.
- */
-void Curl_detach_connnection(struct Curl_easy *data)
+/* 
+ * Curl_detach_connnection() removes the given transfer from the connection. 
+ * 
+ * This is the only function that should clear data->conn. This will 
+ * occasionally be called with the data->conn pointer already cleared. 
+ */ 
+void Curl_detach_connnection(struct Curl_easy *data) 
 {
   struct connectdata *conn = data->conn;
   if(conn)
@@ -879,11 +879,11 @@ void Curl_detach_connnection(struct Curl_easy *data)
   data->conn = NULL;
 }
 
-/*
- * Curl_attach_connnection() attaches this transfer to this connection.
- *
- * This is the only function that should assign data->conn
- */
+/* 
+ * Curl_attach_connnection() attaches this transfer to this connection. 
+ * 
+ * This is the only function that should assign data->conn 
+ */ 
 void Curl_attach_connnection(struct Curl_easy *data,
                              struct connectdata *conn)
 {
@@ -902,15 +902,15 @@ static int waitconnect_getsock(struct connectdata *conn,
   int rc = 0;
 
 #ifdef USE_SSL
-#ifndef CURL_DISABLE_PROXY
+#ifndef CURL_DISABLE_PROXY 
   if(CONNECT_FIRSTSOCKET_PROXY_SSL())
     return Curl_ssl_getsock(conn, sock);
 #endif
-#endif
-
-  if(SOCKS_STATE(conn->cnnct.state))
-    return Curl_SOCKS_getsock(conn, sock, FIRSTSOCKET);
+#endif 
 
+  if(SOCKS_STATE(conn->cnnct.state)) 
+    return Curl_SOCKS_getsock(conn, sock, FIRSTSOCKET); 
+ 
   for(i = 0; i<2; i++) {
     if(conn->tempsock[i] != CURL_SOCKET_BAD) {
       sock[s] = conn->tempsock[i];
@@ -1074,8 +1074,8 @@ static CURLMcode Curl_multi_wait(struct Curl_multi *multi,
                                  unsigned int extra_nfds,
                                  int timeout_ms,
                                  int *ret,
-                                 bool extrawait, /* when no socket, wait */
-                                 bool use_wakeup)
+                                 bool extrawait, /* when no socket, wait */ 
+                                 bool use_wakeup) 
 {
   struct Curl_easy *data;
   curl_socket_t sockbunch[MAX_SOCKSPEREASYHANDLE];
@@ -1087,7 +1087,7 @@ static CURLMcode Curl_multi_wait(struct Curl_multi *multi,
   int retcode = 0;
   struct pollfd a_few_on_stack[NUM_POLLS_ON_STACK];
   struct pollfd *ufds = &a_few_on_stack[0];
-  bool ufds_malloc = FALSE;
+  bool ufds_malloc = FALSE; 
 
   if(!GOOD_MULTI_HANDLE(multi))
     return CURLM_BAD_HANDLE;
@@ -1095,9 +1095,9 @@ static CURLMcode Curl_multi_wait(struct Curl_multi *multi,
   if(multi->in_callback)
     return CURLM_RECURSIVE_API_CALL;
 
-  if(timeout_ms < 0)
-    return CURLM_BAD_FUNCTION_ARGUMENT;
-
+  if(timeout_ms < 0) 
+    return CURLM_BAD_FUNCTION_ARGUMENT; 
+ 
   /* Count up how many fds we have from the multi handle */
   data = multi->easyp;
   while(data) {
@@ -1132,12 +1132,12 @@ static CURLMcode Curl_multi_wait(struct Curl_multi *multi,
   curlfds = nfds; /* number of internal file descriptors */
   nfds += extra_nfds; /* add the externally provided ones */
 
-#ifdef ENABLE_WAKEUP
-  if(use_wakeup && multi->wakeup_pair[0] != CURL_SOCKET_BAD) {
-    ++nfds;
-  }
-#endif
-
+#ifdef ENABLE_WAKEUP 
+  if(use_wakeup && multi->wakeup_pair[0] != CURL_SOCKET_BAD) { 
+    ++nfds; 
+  } 
+#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
@@ -1159,7 +1159,7 @@ static CURLMcode Curl_multi_wait(struct Curl_multi *multi,
     while(data) {
       bitmap = multi_getsock(data, sockbunch);
 
-      for(i = 0; i < MAX_SOCKSPEREASYHANDLE; i++) {
+      for(i = 0; i < MAX_SOCKSPEREASYHANDLE; i++) { 
         curl_socket_t s = CURL_SOCKET_BAD;
 
         if(bitmap & GETSOCK_READSOCK(i)) {
@@ -1196,17 +1196,17 @@ static CURLMcode Curl_multi_wait(struct Curl_multi *multi,
     ++nfds;
   }
 
-#ifdef ENABLE_WAKEUP
-  if(use_wakeup && multi->wakeup_pair[0] != CURL_SOCKET_BAD) {
-    ufds[nfds].fd = multi->wakeup_pair[0];
-    ufds[nfds].events = POLLIN;
-    ++nfds;
-  }
-#endif
-
+#ifdef ENABLE_WAKEUP 
+  if(use_wakeup && multi->wakeup_pair[0] != CURL_SOCKET_BAD) { 
+    ufds[nfds].fd = multi->wakeup_pair[0]; 
+    ufds[nfds].events = POLLIN; 
+    ++nfds; 
+  } 
+#endif 
+ 
   if(nfds) {
     /* wait... */
-    int pollrc = Curl_poll(ufds, nfds, timeout_ms);
+    int pollrc = Curl_poll(ufds, nfds, timeout_ms); 
     if(pollrc > 0) {
       retcode = pollrc;
       /* copy revents results from the poll to the curl_multi_wait poll
@@ -1224,31 +1224,31 @@ static CURLMcode Curl_multi_wait(struct Curl_multi *multi,
           mask |= CURL_WAIT_POLLPRI;
         extra_fds[i].revents = mask;
       }
-
-#ifdef ENABLE_WAKEUP
-      if(use_wakeup && multi->wakeup_pair[0] != CURL_SOCKET_BAD) {
-        if(ufds[curlfds + extra_nfds].revents & POLLIN) {
-          char buf[64];
-          ssize_t nread;
-          while(1) {
-            /* the reading socket is non-blocking, try to read
-               data from it until it receives an error (except EINTR).
-               In normal cases it will get EAGAIN or EWOULDBLOCK
-               when there is no more data, breaking the loop. */
-            nread = sread(multi->wakeup_pair[0], buf, sizeof(buf));
-            if(nread <= 0) {
-#ifndef USE_WINSOCK
-              if(nread < 0 && EINTR == SOCKERRNO)
-                continue;
-#endif
-              break;
-            }
-          }
-          /* do not count the wakeup socket into the returned value */
-          retcode--;
-        }
-      }
-#endif
+ 
+#ifdef ENABLE_WAKEUP 
+      if(use_wakeup && multi->wakeup_pair[0] != CURL_SOCKET_BAD) { 
+        if(ufds[curlfds + extra_nfds].revents & POLLIN) { 
+          char buf[64]; 
+          ssize_t nread; 
+          while(1) { 
+            /* the reading socket is non-blocking, try to read 
+               data from it until it receives an error (except EINTR). 
+               In normal cases it will get EAGAIN or EWOULDBLOCK 
+               when there is no more data, breaking the loop. */ 
+            nread = sread(multi->wakeup_pair[0], buf, sizeof(buf)); 
+            if(nread <= 0) { 
+#ifndef USE_WINSOCK 
+              if(nread < 0 && EINTR == SOCKERRNO) 
+                continue; 
+#endif 
+              break; 
+            } 
+          } 
+          /* do not count the wakeup socket into the returned value */ 
+          retcode--; 
+        } 
+      } 
+#endif 
     }
   }
 
@@ -1256,7 +1256,7 @@ static CURLMcode Curl_multi_wait(struct Curl_multi *multi,
     free(ufds);
   if(ret)
     *ret = retcode;
-  if(!extrawait || nfds)
+  if(!extrawait || nfds) 
     /* if any socket was checked */
     ;
   else {
@@ -1266,11 +1266,11 @@ static CURLMcode Curl_multi_wait(struct Curl_multi *multi,
     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);
+      /* 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); 
     }
   }
 
@@ -1283,8 +1283,8 @@ CURLMcode curl_multi_wait(struct Curl_multi *multi,
                           int timeout_ms,
                           int *ret)
 {
-  return Curl_multi_wait(multi, extra_fds, extra_nfds, timeout_ms, ret, FALSE,
-                         FALSE);
+  return Curl_multi_wait(multi, extra_fds, extra_nfds, timeout_ms, ret, FALSE, 
+                         FALSE); 
 }
 
 CURLMcode curl_multi_poll(struct Curl_multi *multi,
@@ -1293,57 +1293,57 @@ CURLMcode curl_multi_poll(struct Curl_multi *multi,
                           int timeout_ms,
                           int *ret)
 {
-  return Curl_multi_wait(multi, extra_fds, extra_nfds, timeout_ms, ret, TRUE,
-                         TRUE);
-}
-
-CURLMcode curl_multi_wakeup(struct Curl_multi *multi)
-{
-  /* this function is usually called from another thread,
-     it has to be careful only to access parts of the
-     Curl_multi struct that are constant */
-
-  /* GOOD_MULTI_HANDLE can be safely called */
-  if(!GOOD_MULTI_HANDLE(multi))
-    return CURLM_BAD_HANDLE;
-
-#ifdef ENABLE_WAKEUP
-  /* the wakeup_pair variable is only written during init and cleanup,
-     making it safe to access from another thread after the init part
-     and before cleanup */
-  if(multi->wakeup_pair[1] != CURL_SOCKET_BAD) {
-    char buf[1];
-    buf[0] = 1;
-    while(1) {
-      /* swrite() is not thread-safe in general, because concurrent calls
-         can have their messages interleaved, but in this case the content
-         of the messages does not matter, which makes it ok to call.
-
-         The write socket is set to non-blocking, this way this function
-         cannot block, making it safe to call even from the same thread
-         that will call Curl_multi_wait(). If swrite() returns that it
-         would block, it's considered successful because it means that
-         previous calls to this function will wake up the poll(). */
-      if(swrite(multi->wakeup_pair[1], buf, sizeof(buf)) < 0) {
-        int err = SOCKERRNO;
-        int return_success;
-#ifdef USE_WINSOCK
-        return_success = WSAEWOULDBLOCK == err;
-#else
-        if(EINTR == err)
-          continue;
-        return_success = EWOULDBLOCK == err || EAGAIN == err;
-#endif
-        if(!return_success)
-          return CURLM_WAKEUP_FAILURE;
-      }
-      return CURLM_OK;
-    }
-  }
-#endif
-  return CURLM_WAKEUP_FAILURE;
-}
-
+  return Curl_multi_wait(multi, extra_fds, extra_nfds, timeout_ms, ret, TRUE, 
+                         TRUE); 
+}
+
+CURLMcode curl_multi_wakeup(struct Curl_multi *multi) 
+{ 
+  /* this function is usually called from another thread, 
+     it has to be careful only to access parts of the 
+     Curl_multi struct that are constant */ 
+ 
+  /* GOOD_MULTI_HANDLE can be safely called */ 
+  if(!GOOD_MULTI_HANDLE(multi)) 
+    return CURLM_BAD_HANDLE; 
+ 
+#ifdef ENABLE_WAKEUP 
+  /* the wakeup_pair variable is only written during init and cleanup, 
+     making it safe to access from another thread after the init part 
+     and before cleanup */ 
+  if(multi->wakeup_pair[1] != CURL_SOCKET_BAD) { 
+    char buf[1]; 
+    buf[0] = 1; 
+    while(1) { 
+      /* swrite() is not thread-safe in general, because concurrent calls 
+         can have their messages interleaved, but in this case the content 
+         of the messages does not matter, which makes it ok to call. 
+ 
+         The write socket is set to non-blocking, this way this function 
+         cannot block, making it safe to call even from the same thread 
+         that will call Curl_multi_wait(). If swrite() returns that it 
+         would block, it's considered successful because it means that 
+         previous calls to this function will wake up the poll(). */ 
+      if(swrite(multi->wakeup_pair[1], buf, sizeof(buf)) < 0) { 
+        int err = SOCKERRNO; 
+        int return_success; 
+#ifdef USE_WINSOCK 
+        return_success = WSAEWOULDBLOCK == err; 
+#else 
+        if(EINTR == err) 
+          continue; 
+        return_success = EWOULDBLOCK == err || EAGAIN == err; 
+#endif 
+        if(!return_success) 
+          return CURLM_WAKEUP_FAILURE; 
+      } 
+      return CURLM_OK; 
+    } 
+  } 
+#endif 
+  return CURLM_WAKEUP_FAILURE; 
+} 
+ 
 /*
  * multi_ischanged() is called
  *
@@ -1404,7 +1404,7 @@ static CURLcode multi_do(struct Curl_easy *data, bool *done)
 
   DEBUGASSERT(conn);
   DEBUGASSERT(conn->handler);
-  DEBUGASSERT(conn->data == data);
+  DEBUGASSERT(conn->data == data); 
 
   if(conn->handler->do_it) {
     /* generic protocol-specific function pointer set in curl_connect() */
@@ -1511,7 +1511,7 @@ static CURLcode protocol_connect(struct connectdata *conn,
   }
 
   if(!conn->bits.protoconnstart) {
-#ifndef CURL_DISABLE_PROXY
+#ifndef CURL_DISABLE_PROXY 
     result = Curl_proxy_connect(conn, FIRSTSOCKET);
     if(result)
       return result;
@@ -1525,7 +1525,7 @@ static CURLcode protocol_connect(struct connectdata *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
+#endif 
     if(conn->handler->connect_it) {
       /* is there a protocol-specific connect() procedure? */
 
@@ -1544,24 +1544,24 @@ static CURLcode protocol_connect(struct connectdata *conn,
   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
- * transfer.
- */
-CURLcode Curl_preconnect(struct Curl_easy *data)
-{
-  if(!data->state.buffer) {
-    data->state.buffer = malloc(data->set.buffer_size + 1);
-    if(!data->state.buffer)
-      return CURLE_OUT_OF_MEMORY;
-  }
-  return CURLE_OK;
-}
-
-
+/* 
+ * Curl_preconnect() is called immediately before a connect starts. When a 
+ * redirect is followed, this is then called multiple times during a single 
+ * transfer. 
+ */ 
+CURLcode Curl_preconnect(struct Curl_easy *data) 
+{ 
+  if(!data->state.buffer) { 
+    data->state.buffer = malloc(data->set.buffer_size + 1); 
+    if(!data->state.buffer) 
+      return CURLE_OUT_OF_MEMORY; 
+  } 
+  return CURLE_OK; 
+} 
+
+ 
 static CURLMcode multi_runsingle(struct Curl_multi *multi,
-                                 struct curltime *nowp,
+                                 struct curltime *nowp, 
                                  struct Curl_easy *data)
 {
   struct Curl_message *msg = NULL;
@@ -1602,7 +1602,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
        (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,
+      timeout_ms = Curl_timeleft(data, nowp, 
                                  (data->mstate <= CURLM_STATE_DO)?
                                  TRUE:FALSE);
 
@@ -1611,25 +1611,25 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
         if(data->mstate == CURLM_STATE_WAITRESOLVE)
           failf(data, "Resolving timed out after %" CURL_FORMAT_TIMEDIFF_T
                 " milliseconds",
-                Curl_timediff(*nowp, data->progress.t_startsingle));
+                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",
-                Curl_timediff(*nowp, data->progress.t_startsingle));
+                Curl_timediff(*nowp, data->progress.t_startsingle)); 
         else {
           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 %"
                   CURL_FORMAT_CURL_OFF_T " bytes received",
-                  Curl_timediff(*nowp, data->progress.t_startsingle),
+                  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",
-                  Curl_timediff(*nowp, data->progress.t_startsingle),
+                  Curl_timediff(*nowp, data->progress.t_startsingle), 
                   k->bytecount);
           }
         }
@@ -1654,7 +1654,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
       if(!result) {
         /* after init, go CONNECT */
         multistate(data, CURLM_STATE_CONNECT);
-        *nowp = Curl_pgrsTime(data, TIMER_STARTOP);
+        *nowp = Curl_pgrsTime(data, TIMER_STARTOP); 
         rc = CURLM_CALL_MULTI_PERFORM;
       }
       break;
@@ -1666,12 +1666,12 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
 
     case CURLM_STATE_CONNECT:
       /* Connect. We want to get a connection identifier filled in. */
-      /* init this transfer. */
-      result = Curl_preconnect(data);
-      if(result)
-        break;
-
-      *nowp = Curl_pgrsTime(data, TIMER_STARTSINGLE);
+      /* init this transfer. */ 
+      result = Curl_preconnect(data); 
+      if(result) 
+        break; 
+ 
+      *nowp = Curl_pgrsTime(data, TIMER_STARTSINGLE); 
       if(data->set.timeout)
         Curl_expire(data, data->set.timeout, EXPIRE_TIMEOUT);
 
@@ -1728,12 +1728,12 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
       const char *hostname;
 
       DEBUGASSERT(conn);
-#ifndef CURL_DISABLE_PROXY
+#ifndef CURL_DISABLE_PROXY 
       if(conn->bits.httpproxy)
         hostname = conn->http_proxy.host.name;
-      else
-#endif
-        if(conn->bits.conn_to_host)
+      else 
+#endif 
+        if(conn->bits.conn_to_host) 
         hostname = conn->conn_to_host.name;
       else
         hostname = conn->host.name;
@@ -1799,7 +1799,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
       /* this is HTTP-specific, but sending CONNECT to a proxy is HTTP... */
       DEBUGASSERT(data->conn);
       result = Curl_http_connect(data->conn, &protocol_connected);
-#ifndef CURL_DISABLE_PROXY
+#ifndef CURL_DISABLE_PROXY 
       if(data->conn->bits.proxy_connect_closed) {
         rc = CURLM_CALL_MULTI_PERFORM;
         /* connect back to proxy again */
@@ -1807,21 +1807,21 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
         multi_done(data, CURLE_OK, FALSE);
         multistate(data, CURLM_STATE_CONNECT);
       }
-      else
-#endif
-        if(!result) {
-          if(
-#ifndef CURL_DISABLE_PROXY
-            (data->conn->http_proxy.proxytype != CURLPROXY_HTTPS ||
-             data->conn->bits.proxy_ssl_connected[FIRSTSOCKET]) &&
-#endif
-            Curl_connect_complete(data->conn)) {
-            rc = CURLM_CALL_MULTI_PERFORM;
-            /* initiate protocol connect phase */
-            multistate(data, CURLM_STATE_SENDPROTOCONNECT);
-          }
+      else 
+#endif 
+        if(!result) { 
+          if( 
+#ifndef CURL_DISABLE_PROXY 
+            (data->conn->http_proxy.proxytype != CURLPROXY_HTTPS || 
+             data->conn->bits.proxy_ssl_connected[FIRSTSOCKET]) && 
+#endif 
+            Curl_connect_complete(data->conn)) { 
+            rc = CURLM_CALL_MULTI_PERFORM; 
+            /* initiate protocol connect phase */ 
+            multistate(data, CURLM_STATE_SENDPROTOCONNECT); 
+          } 
         }
-      else
+      else 
         stream_error = TRUE;
       break;
 #endif
@@ -1832,25 +1832,25 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
       result = Curl_is_connected(data->conn, FIRSTSOCKET, &connected);
       if(connected && !result) {
 #ifndef CURL_DISABLE_HTTP
-        if(
-#ifndef CURL_DISABLE_PROXY
-          (data->conn->http_proxy.proxytype == CURLPROXY_HTTPS &&
-           !data->conn->bits.proxy_ssl_connected[FIRSTSOCKET]) ||
-#endif
-          Curl_connect_ongoing(data->conn)) {
+        if( 
+#ifndef CURL_DISABLE_PROXY 
+          (data->conn->http_proxy.proxytype == CURLPROXY_HTTPS && 
+           !data->conn->bits.proxy_ssl_connected[FIRSTSOCKET]) || 
+#endif 
+          Curl_connect_ongoing(data->conn)) { 
           multistate(data, CURLM_STATE_WAITPROXYCONNECT);
           break;
         }
 #endif
         rc = CURLM_CALL_MULTI_PERFORM;
-#ifndef CURL_DISABLE_PROXY
-        multistate(data,
-                   data->conn->bits.tunnel_proxy?
+#ifndef CURL_DISABLE_PROXY 
+        multistate(data, 
+                   data->conn->bits.tunnel_proxy? 
                    CURLM_STATE_WAITPROXYCONNECT:
                    CURLM_STATE_SENDPROTOCONNECT);
-#else
-        multistate(data, CURLM_STATE_SENDPROTOCONNECT);
-#endif
+#else 
+        multistate(data, CURLM_STATE_SENDPROTOCONNECT); 
+#endif 
       }
       else if(result) {
         /* failure detected */
@@ -1871,7 +1871,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
         multistate(data, CURLM_STATE_DO);
         rc = CURLM_CALL_MULTI_PERFORM;
       }
-      else {
+      else { 
         /* failure detected */
         Curl_posttransfer(data);
         multi_done(data, result, TRUE);
@@ -2079,7 +2079,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
       if(Curl_pgrsUpdate(data->conn))
         result = CURLE_ABORTED_BY_CALLBACK;
       else
-        result = Curl_speedcheck(data, *nowp);
+        result = Curl_speedcheck(data, *nowp); 
 
       if(!result) {
         send_timeout_ms = 0;
@@ -2089,7 +2089,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
                                    data->progress.ul_limit_size,
                                    data->set.max_send_speed,
                                    data->progress.ul_limit_start,
-                                   *nowp);
+                                   *nowp); 
 
         recv_timeout_ms = 0;
         if(data->set.max_recv_speed > 0)
@@ -2098,11 +2098,11 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
                                    data->progress.dl_limit_size,
                                    data->set.max_recv_speed,
                                    data->progress.dl_limit_start,
-                                   *nowp);
+                                   *nowp); 
 
         if(!send_timeout_ms && !recv_timeout_ms) {
           multistate(data, CURLM_STATE_PERFORM);
-          Curl_ratelimit(data, *nowp);
+          Curl_ratelimit(data, *nowp); 
         }
         else if(send_timeout_ms >= recv_timeout_ms)
           Curl_expire(data, send_timeout_ms, EXPIRE_TOOFAST);
@@ -2116,7 +2116,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
       char *newurl = NULL;
       bool retry = FALSE;
       bool comeback = FALSE;
-      DEBUGASSERT(data->state.buffer);
+      DEBUGASSERT(data->state.buffer); 
       /* check if over send speed */
       send_timeout_ms = 0;
       if(data->set.max_send_speed > 0)
@@ -2124,7 +2124,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
                                                  data->progress.ul_limit_size,
                                                  data->set.max_send_speed,
                                                  data->progress.ul_limit_start,
-                                                 *nowp);
+                                                 *nowp); 
 
       /* check if over recv speed */
       recv_timeout_ms = 0;
@@ -2133,10 +2133,10 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
                                                  data->progress.dl_limit_size,
                                                  data->set.max_recv_speed,
                                                  data->progress.dl_limit_start,
-                                                 *nowp);
+                                                 *nowp); 
 
       if(send_timeout_ms || recv_timeout_ms) {
-        Curl_ratelimit(data, *nowp);
+        Curl_ratelimit(data, *nowp); 
         multistate(data, CURLM_STATE_TOOFAST);
         if(send_timeout_ms >= recv_timeout_ms)
           Curl_expire(data, send_timeout_ms, EXPIRE_TOOFAST);
@@ -2255,13 +2255,13 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
           }
         }
       }
-      else if(comeback) {
-        /* This avoids CURLM_CALL_MULTI_PERFORM so that a very fast transfer
-           won't get stuck on this transfer at the expense of other concurrent
-           transfers */
-        Curl_expire(data, 0, EXPIRE_RUN_NOW);
-        rc = CURLM_OK;
-      }
+      else if(comeback) { 
+        /* This avoids CURLM_CALL_MULTI_PERFORM so that a very fast transfer 
+           won't get stuck on this transfer at the expense of other concurrent 
+           transfers */ 
+        Curl_expire(data, 0, EXPIRE_RUN_NOW); 
+        rc = CURLM_OK; 
+      } 
       break;
     }
 
@@ -2289,7 +2289,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
          * 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);
+        Curl_detach_connnection(data); 
       }
 
 #ifndef CURL_DISABLE_FTP
@@ -2341,11 +2341,11 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
             /* 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);
+            Curl_detach_connnection(data); 
 
+            /* remove connection from cache */ 
+            Curl_conncache_remove_conn(data, conn, TRUE); 
+ 
             /* disconnect properly */
             Curl_disconnect(data, conn, dead_connection);
           }
@@ -2416,7 +2416,7 @@ CURLMcode curl_multi_perform(struct Curl_multi *multi, int *running_handles)
     SIGPIPE_VARIABLE(pipe_st);
 
     sigpipe_ignore(data, &pipe_st);
-    result = multi_runsingle(multi, &now, data);
+    result = multi_runsingle(multi, &now, data); 
     sigpipe_restore(&pipe_st);
 
     if(result)
@@ -2498,11 +2498,11 @@ CURLMcode curl_multi_cleanup(struct Curl_multi *multi)
 
     Curl_hash_destroy(&multi->hostcache);
     Curl_psl_destroy(&multi->psl);
-
-#ifdef ENABLE_WAKEUP
-    sclose(multi->wakeup_pair[0]);
-    sclose(multi->wakeup_pair[1]);
-#endif
+ 
+#ifdef ENABLE_WAKEUP 
+    sclose(multi->wakeup_pair[0]); 
+    sclose(multi->wakeup_pair[1]); 
+#endif 
     free(multi);
 
     return CURLM_OK;
@@ -2530,7 +2530,7 @@ CURLMsg *curl_multi_info_read(struct Curl_multi *multi, int *msgs_in_queue)
      !multi->in_callback &&
      Curl_llist_count(&multi->msglist)) {
     /* there is one or more messages in the list */
-    struct Curl_llist_element *e;
+    struct Curl_llist_element *e; 
 
     /* extract the head of the list to return */
     e = multi->msglist.head;
@@ -2760,15 +2760,15 @@ static CURLMcode add_next_timeout(struct curltime now,
                                   struct Curl_easy *d)
 {
   struct curltime *tv = &d->state.expiretime;
-  struct Curl_llist *list = &d->state.timeoutlist;
-  struct Curl_llist_element *e;
+  struct Curl_llist *list = &d->state.timeoutlist; 
+  struct Curl_llist_element *e; 
   struct time_node *node = NULL;
 
   /* move over the timeout list for this specific handle and remove all
      timeouts that are now passed tense and store the next pending
      timeout in *tv */
   for(e = list->head; e;) {
-    struct Curl_llist_element *n = e->next;
+    struct Curl_llist_element *n = e->next; 
     timediff_t diff;
     node = (struct time_node *)e->ptr;
     diff = Curl_timediff(node->time, now);
@@ -2838,8 +2838,8 @@ static CURLMcode multi_socket(struct Curl_multi *multi,
          and just move on. */
       ;
     else {
-      struct Curl_hash_iterator iter;
-      struct Curl_hash_element *he;
+      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);
@@ -2886,7 +2886,7 @@ static CURLMcode multi_socket(struct Curl_multi *multi,
       SIGPIPE_VARIABLE(pipe_st);
 
       sigpipe_ignore(data, &pipe_st);
-      result = multi_runsingle(multi, &now, data);
+      result = multi_runsingle(multi, &now, data); 
       sigpipe_restore(&pipe_st);
 
       if(CURLM_OK >= result) {
@@ -2970,14 +2970,14 @@ CURLMcode curl_multi_setopt(struct Curl_multi *multi,
     break;
   case CURLMOPT_PIPELINING_SERVER_BL:
     break;
-  case CURLMOPT_MAX_CONCURRENT_STREAMS:
-    {
-      long streams = va_arg(param, long);
-      if(streams < 1)
-        streams = 100;
-      multi->max_concurrent_streams = curlx_sltoui(streams);
-    }
-    break;
+  case CURLMOPT_MAX_CONCURRENT_STREAMS: 
+    { 
+      long streams = va_arg(param, long); 
+      if(streams < 1) 
+        streams = 100; 
+      multi->max_concurrent_streams = curlx_sltoui(streams); 
+    } 
+    break; 
   default:
     res = CURLM_UNKNOWN_OPTION;
     break;
@@ -3121,8 +3121,8 @@ void Curl_update_timer(struct Curl_multi *multi)
 static void
 multi_deltimeout(struct Curl_easy *data, expire_id eid)
 {
-  struct Curl_llist_element *e;
-  struct Curl_llist *timeoutlist = &data->state.timeoutlist;
+  struct Curl_llist_element *e; 
+  struct Curl_llist *timeoutlist = &data->state.timeoutlist; 
   /* find and remove the specific node from the list */
   for(e = timeoutlist->head; e; e = e->next) {
     struct time_node *n = (struct time_node *)e->ptr;
@@ -3145,11 +3145,11 @@ multi_addtimeout(struct Curl_easy *data,
                  struct curltime *stamp,
                  expire_id eid)
 {
-  struct Curl_llist_element *e;
+  struct Curl_llist_element *e; 
   struct time_node *node;
-  struct Curl_llist_element *prev = NULL;
+  struct Curl_llist_element *prev = NULL; 
   size_t n;
-  struct Curl_llist *timeoutlist = &data->state.timeoutlist;
+  struct Curl_llist *timeoutlist = &data->state.timeoutlist; 
 
   node = &data->state.expires[eid];
 
@@ -3231,8 +3231,8 @@ void Curl_expire(struct Curl_easy *data, timediff_t milli, expire_id id)
 
     /* Since this is an updated time, we must remove the previous entry from
        the splay tree first and then re-add the new value */
-    rc = Curl_splayremove(multi->timetree, &data->state.timenode,
-                          &multi->timetree);
+    rc = Curl_splayremove(multi->timetree, &data->state.timenode, 
+                          &multi->timetree); 
     if(rc)
       infof(data, "Internal error removing splay node = %d\n", rc);
   }
@@ -3275,11 +3275,11 @@ void Curl_expire_clear(struct Curl_easy *data)
   if(nowp->tv_sec || nowp->tv_usec) {
     /* Since this is an cleared time, we must remove the previous entry from
        the splay tree */
-    struct Curl_llist *list = &data->state.timeoutlist;
+    struct Curl_llist *list = &data->state.timeoutlist; 
     int rc;
 
-    rc = Curl_splayremove(multi->timetree, &data->state.timenode,
-                          &multi->timetree);
+    rc = Curl_splayremove(multi->timetree, &data->state.timenode, 
+                          &multi->timetree); 
     if(rc)
       infof(data, "Internal error clearing splay node = %d\n", rc);
 
@@ -3345,7 +3345,7 @@ void Curl_multiuse_state(struct connectdata *conn,
 
 static void process_pending_handles(struct Curl_multi *multi)
 {
-  struct Curl_llist_element *e = multi->pending.head;
+  struct Curl_llist_element *e = multi->pending.head; 
   if(e) {
     struct Curl_easy *data = e->ptr;
 
@@ -3413,9 +3413,9 @@ void Curl_multi_dump(struct Curl_multi *multi)
   }
 }
 #endif
-
-unsigned int Curl_multi_max_concurrent_streams(struct Curl_multi *multi)
-{
-  DEBUGASSERT(multi);
-  return multi->max_concurrent_streams;
-}
+ 
+unsigned int Curl_multi_max_concurrent_streams(struct Curl_multi *multi) 
+{ 
+  DEBUGASSERT(multi); 
+  return multi->max_concurrent_streams; 
+}