Restoring authorship annotation for Nikita Slyusarev <nslus@yandex-team.com>. Commit 2 of 2.

1 files changed, 551 insertions, 551 deletions

diff --git a/contrib/libs/curl/lib/asyn-ares.c b/contrib/libs/curl/lib/asyn-ares.c
index 8cf5aa9c0f..1747571889 100644
--- a/contrib/libs/curl/lib/asyn-ares.c
+++ b/contrib/libs/curl/lib/asyn-ares.c
@@ -1,98 +1,98 @@
-/*************************************************************************** 
- *                                  _   _ ____  _ 
- *  Project                     ___| | | |  _ \| | 
- *                             / __| | | | |_) | | 
- *                            | (__| |_| |  _ <| |___ 
- *                             \___|\___/|_| \_\_____| 
- * 
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
  * Copyright (C) 1998 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
- * 
- * This software is licensed as described in the file COPYING, which 
- * you should have received as part of this distribution. The terms 
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
  * are also available at https://curl.se/docs/copyright.html.
- * 
- * You may opt to use, copy, modify, merge, publish, distribute and/or sell 
- * copies of the Software, and permit persons to whom the Software is 
- * furnished to do so, under the terms of the COPYING file. 
- * 
- * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY 
- * KIND, either express or implied. 
- * 
- ***************************************************************************/ 
- 
-#include "curl_setup.h" 
- 
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+#include "curl_setup.h"
+
 /***********************************************************************
  * Only for ares-enabled builds
  * And only for functions that fulfill the asynch resolver backend API
  * as defined in asyn.h, nothing else belongs in this file!
  **********************************************************************/
- 
+
 #ifdef CURLRES_ARES
 
-#include <limits.h> 
-#ifdef HAVE_NETINET_IN_H 
-#include <netinet/in.h> 
-#endif 
-#ifdef HAVE_NETDB_H 
-#include <netdb.h> 
-#endif 
-#ifdef HAVE_ARPA_INET_H 
-#include <arpa/inet.h> 
-#endif 
-#ifdef __VMS 
-#include <in.h> 
-#include <inet.h> 
-#endif 
- 
-#ifdef HAVE_PROCESS_H 
-#include <process.h> 
-#endif 
- 
-#if (defined(NETWARE) && defined(__NOVELL_LIBC__)) 
-#undef in_addr_t 
-#define in_addr_t unsigned long 
-#endif 
- 
-#include "urldata.h" 
-#include "sendf.h" 
-#include "hostip.h" 
-#include "hash.h" 
-#include "share.h" 
-#include "strerror.h" 
-#include "url.h" 
-#include "multiif.h" 
-#include "inet_pton.h" 
-#include "connect.h" 
-#include "select.h" 
-#include "progress.h" 
- 
+#include <limits.h>
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_NETDB_H
+#include <netdb.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
+#ifdef __VMS
+#include <in.h>
+#include <inet.h>
+#endif
+
+#ifdef HAVE_PROCESS_H
+#include <process.h>
+#endif
+
+#if (defined(NETWARE) && defined(__NOVELL_LIBC__))
+#undef in_addr_t
+#define in_addr_t unsigned long
+#endif
+
+#include "urldata.h"
+#include "sendf.h"
+#include "hostip.h"
+#include "hash.h"
+#include "share.h"
+#include "strerror.h"
+#include "url.h"
+#include "multiif.h"
+#include "inet_pton.h"
+#include "connect.h"
+#include "select.h"
+#include "progress.h"
+
 #  if defined(CURL_STATICLIB) && !defined(CARES_STATICLIB) &&   \
   defined(WIN32)
-#    define CARES_STATICLIB 
-#  endif 
-#  include <ares.h> 
-#  include <ares_version.h> /* really old c-ares didn't include this by 
-                               itself */ 
- 
-#if ARES_VERSION >= 0x010500 
-/* c-ares 1.5.0 or later, the callback proto is modified */ 
-#define HAVE_CARES_CALLBACK_TIMEOUTS 1 
-#endif 
- 
+#    define CARES_STATICLIB
+#  endif
+#  include <ares.h>
+#  include <ares_version.h> /* really old c-ares didn't include this by
+                               itself */
+
+#if ARES_VERSION >= 0x010500
+/* c-ares 1.5.0 or later, the callback proto is modified */
+#define HAVE_CARES_CALLBACK_TIMEOUTS 1
+#endif
+
 /* The last 3 #include files should be in this order */
 #include "curl_printf.h"
-#include "curl_memory.h" 
-#include "memdebug.h" 
- 
+#include "curl_memory.h"
+#include "memdebug.h"
+
 struct thread_data {
-  int num_pending; /* number of ares_gethostbyname() requests */ 
+  int num_pending; /* number of ares_gethostbyname() requests */
   struct Curl_addrinfo *temp_ai; /* intermediary result while fetching c-ares
                                     parts */
-  int last_status; 
+  int last_status;
   struct curltime happy_eyeballs_dns_time; /* when this timer started, or 0 */
-}; 
- 
+};
+
 /* How long we are willing to wait for additional parallel responses after
    obtaining a "definitive" one.
 
@@ -104,34 +104,34 @@ struct thread_data {
  */
 #define HAPPY_EYEBALLS_DNS_TIMEOUT 5000
 
-/* 
- * Curl_resolver_global_init() - the generic low-level asynchronous name 
- * resolve API.  Called from curl_global_init() to initialize global resolver 
- * environment.  Initializes ares library. 
- */ 
-int Curl_resolver_global_init(void) 
-{ 
-#ifdef CARES_HAVE_ARES_LIBRARY_INIT 
-  if(ares_library_init(ARES_LIB_INIT_ALL)) { 
-    return CURLE_FAILED_INIT; 
-  } 
-#endif 
-  return CURLE_OK; 
-} 
- 
-/* 
- * Curl_resolver_global_cleanup() 
- * 
- * Called from curl_global_cleanup() to destroy global resolver environment. 
- * Deinitializes ares library. 
- */ 
-void Curl_resolver_global_cleanup(void) 
-{ 
-#ifdef CARES_HAVE_ARES_LIBRARY_CLEANUP 
-  ares_library_cleanup(); 
-#endif 
-} 
- 
+/*
+ * Curl_resolver_global_init() - the generic low-level asynchronous name
+ * resolve API.  Called from curl_global_init() to initialize global resolver
+ * environment.  Initializes ares library.
+ */
+int Curl_resolver_global_init(void)
+{
+#ifdef CARES_HAVE_ARES_LIBRARY_INIT
+  if(ares_library_init(ARES_LIB_INIT_ALL)) {
+    return CURLE_FAILED_INIT;
+  }
+#endif
+  return CURLE_OK;
+}
+
+/*
+ * Curl_resolver_global_cleanup()
+ *
+ * Called from curl_global_cleanup() to destroy global resolver environment.
+ * Deinitializes ares library.
+ */
+void Curl_resolver_global_cleanup(void)
+{
+#ifdef CARES_HAVE_ARES_LIBRARY_CLEANUP
+  ares_library_cleanup();
+#endif
+}
+
 
 static void Curl_ares_sock_state_cb(void *data, ares_socket_t socket_fd,
                                     int readable, int writable)
@@ -143,53 +143,53 @@ static void Curl_ares_sock_state_cb(void *data, ares_socket_t socket_fd,
   }
 }
 
-/* 
- * Curl_resolver_init() 
- * 
- * Called from curl_easy_init() -> Curl_open() to initialize resolver 
- * URL-state specific environment ('resolver' member of the UrlState 
- * structure).  Fills the passed pointer by the initialized ares_channel. 
- */ 
+/*
+ * Curl_resolver_init()
+ *
+ * Called from curl_easy_init() -> Curl_open() to initialize resolver
+ * URL-state specific environment ('resolver' member of the UrlState
+ * structure).  Fills the passed pointer by the initialized ares_channel.
+ */
 CURLcode Curl_resolver_init(struct Curl_easy *easy, void **resolver)
-{ 
+{
   int status;
   struct ares_options options;
   int optmask = ARES_OPT_SOCK_STATE_CB;
   options.sock_state_cb = Curl_ares_sock_state_cb;
   options.sock_state_cb_data = easy;
   status = ares_init_options((ares_channel*)resolver, &options, optmask);
-  if(status != ARES_SUCCESS) { 
-    if(status == ARES_ENOMEM) 
-      return CURLE_OUT_OF_MEMORY; 
-    else 
-      return CURLE_FAILED_INIT; 
-  } 
-  return CURLE_OK; 
-  /* make sure that all other returns from this function should destroy the 
-     ares channel before returning error! */ 
-} 
- 
-/* 
- * Curl_resolver_cleanup() 
- * 
- * Called from curl_easy_cleanup() -> Curl_close() to cleanup resolver 
- * URL-state specific environment ('resolver' member of the UrlState 
- * structure).  Destroys the ares channel. 
- */ 
-void Curl_resolver_cleanup(void *resolver) 
-{ 
-  ares_destroy((ares_channel)resolver); 
-} 
- 
-/* 
- * Curl_resolver_duphandle() 
- * 
- * Called from curl_easy_duphandle() to duplicate resolver URL-state specific 
- * environment ('resolver' member of the UrlState structure).  Duplicates the 
- * 'from' ares channel and passes the resulting channel to the 'to' pointer. 
- */ 
+  if(status != ARES_SUCCESS) {
+    if(status == ARES_ENOMEM)
+      return CURLE_OUT_OF_MEMORY;
+    else
+      return CURLE_FAILED_INIT;
+  }
+  return CURLE_OK;
+  /* make sure that all other returns from this function should destroy the
+     ares channel before returning error! */
+}
+
+/*
+ * Curl_resolver_cleanup()
+ *
+ * Called from curl_easy_cleanup() -> Curl_close() to cleanup resolver
+ * URL-state specific environment ('resolver' member of the UrlState
+ * structure).  Destroys the ares channel.
+ */
+void Curl_resolver_cleanup(void *resolver)
+{
+  ares_destroy((ares_channel)resolver);
+}
+
+/*
+ * Curl_resolver_duphandle()
+ *
+ * Called from curl_easy_duphandle() to duplicate resolver URL-state specific
+ * environment ('resolver' member of the UrlState structure).  Duplicates the
+ * 'from' ares channel and passes the resulting channel to the 'to' pointer.
+ */
 CURLcode Curl_resolver_duphandle(struct Curl_easy *easy, void **to, void *from)
-{ 
+{
   (void)from;
   /*
    * it would be better to call ares_dup instead, but right now
@@ -197,21 +197,21 @@ CURLcode Curl_resolver_duphandle(struct Curl_easy *easy, void **to, void *from)
    * ares_init_options
    */
   return Curl_resolver_init(easy, to);
-} 
- 
+}
+
 static void destroy_async_data(struct Curl_async *async);
- 
-/* 
- * Cancel all possibly still on-going resolves for this connection. 
- */ 
-void Curl_resolver_cancel(struct connectdata *conn) 
-{ 
+
+/*
+ * Cancel all possibly still on-going resolves for this connection.
+ */
+void Curl_resolver_cancel(struct connectdata *conn)
+{
   if(conn->data && conn->data->state.resolver)
-    ares_cancel((ares_channel)conn->data->state.resolver); 
-  destroy_async_data(&conn->async); 
-} 
- 
-/* 
+    ares_cancel((ares_channel)conn->data->state.resolver);
+  destroy_async_data(&conn->async);
+}
+
+/*
  * We're equivalent to Curl_resolver_cancel() for the c-ares resolver.  We
  * never block.
  */
@@ -223,140 +223,140 @@ void Curl_resolver_kill(struct connectdata *conn)
 }
 
 /*
- * destroy_async_data() cleans up async resolver data. 
- */ 
+ * destroy_async_data() cleans up async resolver data.
+ */
 static void destroy_async_data(struct Curl_async *async)
-{ 
+{
   free(async->hostname);
- 
+
   if(async->tdata) {
     struct thread_data *res = async->tdata;
-    if(res) { 
-      if(res->temp_ai) { 
-        Curl_freeaddrinfo(res->temp_ai); 
-        res->temp_ai = NULL; 
-      } 
-      free(res); 
-    } 
+    if(res) {
+      if(res->temp_ai) {
+        Curl_freeaddrinfo(res->temp_ai);
+        res->temp_ai = NULL;
+      }
+      free(res);
+    }
     async->tdata = NULL;
-  } 
- 
-  async->hostname = NULL; 
-} 
- 
-/* 
- * Curl_resolver_getsock() is called when someone from the outside world 
- * (using curl_multi_fdset()) wants to get our fd_set setup and we're talking 
- * with ares. The caller must make sure that this function is only called when 
- * we have a working ares channel. 
- * 
- * Returns: sockets-in-use-bitmap 
- */ 
- 
-int Curl_resolver_getsock(struct connectdata *conn, 
+  }
+
+  async->hostname = NULL;
+}
+
+/*
+ * Curl_resolver_getsock() is called when someone from the outside world
+ * (using curl_multi_fdset()) wants to get our fd_set setup and we're talking
+ * with ares. The caller must make sure that this function is only called when
+ * we have a working ares channel.
+ *
+ * Returns: sockets-in-use-bitmap
+ */
+
+int Curl_resolver_getsock(struct connectdata *conn,
                           curl_socket_t *socks)
-{ 
-  struct timeval maxtime; 
-  struct timeval timebuf; 
-  struct timeval *timeout; 
-  long milli; 
-  int max = ares_getsock((ares_channel)conn->data->state.resolver, 
+{
+  struct timeval maxtime;
+  struct timeval timebuf;
+  struct timeval *timeout;
+  long milli;
+  int max = ares_getsock((ares_channel)conn->data->state.resolver,
                          (ares_socket_t *)socks, MAX_SOCKSPEREASYHANDLE);
- 
-  maxtime.tv_sec = CURL_TIMEOUT_RESOLVE; 
-  maxtime.tv_usec = 0; 
- 
-  timeout = ares_timeout((ares_channel)conn->data->state.resolver, &maxtime, 
-                         &timebuf); 
-  milli = (timeout->tv_sec * 1000) + (timeout->tv_usec/1000); 
-  if(milli == 0) 
-    milli += 10; 
+
+  maxtime.tv_sec = CURL_TIMEOUT_RESOLVE;
+  maxtime.tv_usec = 0;
+
+  timeout = ares_timeout((ares_channel)conn->data->state.resolver, &maxtime,
+                         &timebuf);
+  milli = (timeout->tv_sec * 1000) + (timeout->tv_usec/1000);
+  if(milli == 0)
+    milli += 10;
   Curl_expire(conn->data, milli, EXPIRE_ASYNC_NAME);
- 
-  return max; 
-} 
- 
-/* 
- * waitperform() 
- * 
- * 1) Ask ares what sockets it currently plays with, then 
- * 2) wait for the timeout period to check for action on ares' sockets. 
- * 3) tell ares to act on all the sockets marked as "with action" 
- * 
- * return number of sockets it worked on 
- */ 
- 
+
+  return max;
+}
+
+/*
+ * waitperform()
+ *
+ * 1) Ask ares what sockets it currently plays with, then
+ * 2) wait for the timeout period to check for action on ares' sockets.
+ * 3) tell ares to act on all the sockets marked as "with action"
+ *
+ * return number of sockets it worked on
+ */
+
 static int waitperform(struct connectdata *conn, timediff_t timeout_ms)
-{ 
+{
   struct Curl_easy *data = conn->data;
-  int nfds; 
-  int bitmask; 
-  ares_socket_t socks[ARES_GETSOCK_MAXNUM]; 
-  struct pollfd pfd[ARES_GETSOCK_MAXNUM]; 
-  int i; 
-  int num = 0; 
- 
-  bitmask = ares_getsock((ares_channel)data->state.resolver, socks, 
-                         ARES_GETSOCK_MAXNUM); 
- 
+  int nfds;
+  int bitmask;
+  ares_socket_t socks[ARES_GETSOCK_MAXNUM];
+  struct pollfd pfd[ARES_GETSOCK_MAXNUM];
+  int i;
+  int num = 0;
+
+  bitmask = ares_getsock((ares_channel)data->state.resolver, socks,
+                         ARES_GETSOCK_MAXNUM);
+
   for(i = 0; i < ARES_GETSOCK_MAXNUM; i++) {
-    pfd[i].events = 0; 
-    pfd[i].revents = 0; 
-    if(ARES_GETSOCK_READABLE(bitmask, i)) { 
-      pfd[i].fd = socks[i]; 
-      pfd[i].events |= POLLRDNORM|POLLIN; 
-    } 
-    if(ARES_GETSOCK_WRITABLE(bitmask, i)) { 
-      pfd[i].fd = socks[i]; 
-      pfd[i].events |= POLLWRNORM|POLLOUT; 
-    } 
-    if(pfd[i].events != 0) 
-      num++; 
-    else 
-      break; 
-  } 
- 
-  if(num) 
-    nfds = Curl_poll(pfd, num, timeout_ms); 
-  else 
-    nfds = 0; 
- 
-  if(!nfds) 
-    /* Call ares_process() unconditonally here, even if we simply timed out 
-       above, as otherwise the ares name resolve won't timeout! */ 
-    ares_process_fd((ares_channel)data->state.resolver, ARES_SOCKET_BAD, 
-                    ARES_SOCKET_BAD); 
-  else { 
-    /* move through the descriptors and ask for processing on them */ 
+    pfd[i].events = 0;
+    pfd[i].revents = 0;
+    if(ARES_GETSOCK_READABLE(bitmask, i)) {
+      pfd[i].fd = socks[i];
+      pfd[i].events |= POLLRDNORM|POLLIN;
+    }
+    if(ARES_GETSOCK_WRITABLE(bitmask, i)) {
+      pfd[i].fd = socks[i];
+      pfd[i].events |= POLLWRNORM|POLLOUT;
+    }
+    if(pfd[i].events != 0)
+      num++;
+    else
+      break;
+  }
+
+  if(num)
+    nfds = Curl_poll(pfd, num, timeout_ms);
+  else
+    nfds = 0;
+
+  if(!nfds)
+    /* Call ares_process() unconditonally here, even if we simply timed out
+       above, as otherwise the ares name resolve won't timeout! */
+    ares_process_fd((ares_channel)data->state.resolver, ARES_SOCKET_BAD,
+                    ARES_SOCKET_BAD);
+  else {
+    /* move through the descriptors and ask for processing on them */
     for(i = 0; i < num; i++)
-      ares_process_fd((ares_channel)data->state.resolver, 
+      ares_process_fd((ares_channel)data->state.resolver,
                       (pfd[i].revents & (POLLRDNORM|POLLIN))?
-                      pfd[i].fd:ARES_SOCKET_BAD, 
+                      pfd[i].fd:ARES_SOCKET_BAD,
                       (pfd[i].revents & (POLLWRNORM|POLLOUT))?
-                      pfd[i].fd:ARES_SOCKET_BAD); 
-  } 
-  return nfds; 
-} 
- 
-/* 
- * Curl_resolver_is_resolved() is called repeatedly to check if a previous 
- * name resolve request has completed. It should also make sure to time-out if 
- * the operation seems to take too long. 
- * 
- * Returns normal CURLcode errors. 
- */ 
-CURLcode Curl_resolver_is_resolved(struct connectdata *conn, 
-                                   struct Curl_dns_entry **dns) 
-{ 
+                      pfd[i].fd:ARES_SOCKET_BAD);
+  }
+  return nfds;
+}
+
+/*
+ * Curl_resolver_is_resolved() is called repeatedly to check if a previous
+ * name resolve request has completed. It should also make sure to time-out if
+ * the operation seems to take too long.
+ *
+ * Returns normal CURLcode errors.
+ */
+CURLcode Curl_resolver_is_resolved(struct connectdata *conn,
+                                   struct Curl_dns_entry **dns)
+{
   struct Curl_easy *data = conn->data;
   struct thread_data *res = conn->async.tdata;
   CURLcode result = CURLE_OK;
- 
+
   DEBUGASSERT(dns);
   *dns = NULL;
- 
-  waitperform(conn, 0); 
- 
+
+  waitperform(conn, 0);
+
   /* Now that we've checked for any last minute results above, see if there are
      any responses still pending when the EXPIRE_HAPPY_EYEBALLS_DNS timer
      expires. */
@@ -380,92 +380,92 @@ CURLcode Curl_resolver_is_resolved(struct connectdata *conn,
     DEBUGASSERT(res->num_pending == 0);
   }
 
-  if(res && !res->num_pending) { 
+  if(res && !res->num_pending) {
     (void)Curl_addrinfo_callback(conn, res->last_status, res->temp_ai);
     /* temp_ai ownership is moved to the connection, so we need not free-up
        them */
     res->temp_ai = NULL;
 
-    if(!conn->async.dns) { 
-      failf(data, "Could not resolve: %s (%s)", 
-            conn->async.hostname, ares_strerror(conn->async.status)); 
+    if(!conn->async.dns) {
+      failf(data, "Could not resolve: %s (%s)",
+            conn->async.hostname, ares_strerror(conn->async.status));
       result = conn->bits.proxy?CURLE_COULDNT_RESOLVE_PROXY:
-        CURLE_COULDNT_RESOLVE_HOST; 
-    } 
+        CURLE_COULDNT_RESOLVE_HOST;
+    }
     else
-      *dns = conn->async.dns; 
- 
-    destroy_async_data(&conn->async); 
-  } 
- 
+      *dns = conn->async.dns;
+
+    destroy_async_data(&conn->async);
+  }
+
   return result;
-} 
- 
-/* 
- * Curl_resolver_wait_resolv() 
- * 
+}
+
+/*
+ * Curl_resolver_wait_resolv()
+ *
  * Waits for a resolve to finish. This function should be avoided since using
- * this risk getting the multi interface to "hang". 
- * 
+ * this risk getting the multi interface to "hang".
+ *
  * 'entry' MUST be non-NULL.
- * 
+ *
  * Returns CURLE_COULDNT_RESOLVE_HOST if the host was not resolved,
  * CURLE_OPERATION_TIMEDOUT if a time-out occurred, or other errors.
- */ 
-CURLcode Curl_resolver_wait_resolv(struct connectdata *conn, 
-                                   struct Curl_dns_entry **entry) 
-{ 
+ */
+CURLcode Curl_resolver_wait_resolv(struct connectdata *conn,
+                                   struct Curl_dns_entry **entry)
+{
   CURLcode result = CURLE_OK;
   struct Curl_easy *data = conn->data;
   timediff_t timeout;
   struct curltime now = Curl_now();
- 
+
   DEBUGASSERT(entry);
   *entry = NULL; /* clear on entry */
 
-  timeout = Curl_timeleft(data, &now, TRUE); 
+  timeout = Curl_timeleft(data, &now, TRUE);
   if(timeout < 0) {
     /* already expired! */
     connclose(conn, "Timed out before name resolve started");
     return CURLE_OPERATION_TIMEDOUT;
   }
-  if(!timeout) 
-    timeout = CURL_TIMEOUT_RESOLVE * 1000; /* default name resolve timeout */ 
- 
-  /* Wait for the name resolve query to complete. */ 
+  if(!timeout)
+    timeout = CURL_TIMEOUT_RESOLVE * 1000; /* default name resolve timeout */
+
+  /* Wait for the name resolve query to complete. */
   while(!result) {
-    struct timeval *tvp, tv, store; 
-    int itimeout; 
+    struct timeval *tvp, tv, store;
+    int itimeout;
     timediff_t timeout_ms;
- 
+
 #if TIMEDIFF_T_MAX > INT_MAX
     itimeout = (timeout > INT_MAX) ? INT_MAX : (int)timeout;
 #else
     itimeout = (int)timeout;
 #endif
- 
-    store.tv_sec = itimeout/1000; 
-    store.tv_usec = (itimeout%1000)*1000; 
- 
-    tvp = ares_timeout((ares_channel)data->state.resolver, &store, &tv); 
- 
-    /* use the timeout period ares returned to us above if less than one 
-       second is left, otherwise just use 1000ms to make sure the progress 
-       callback gets called frequent enough */ 
-    if(!tvp->tv_sec) 
+
+    store.tv_sec = itimeout/1000;
+    store.tv_usec = (itimeout%1000)*1000;
+
+    tvp = ares_timeout((ares_channel)data->state.resolver, &store, &tv);
+
+    /* use the timeout period ares returned to us above if less than one
+       second is left, otherwise just use 1000ms to make sure the progress
+       callback gets called frequent enough */
+    if(!tvp->tv_sec)
       timeout_ms = (timediff_t)(tvp->tv_usec/1000);
-    else 
-      timeout_ms = 1000; 
- 
-    waitperform(conn, timeout_ms); 
+    else
+      timeout_ms = 1000;
+
+    waitperform(conn, timeout_ms);
     result = Curl_resolver_is_resolved(conn, entry);
- 
+
     if(result || conn->async.done)
-      break; 
- 
+      break;
+
     if(Curl_pgrsUpdate(conn))
       result = CURLE_ABORTED_BY_CALLBACK;
-    else { 
+    else {
       struct curltime now2 = Curl_now();
       timediff_t timediff = Curl_timediff(now2, now); /* spent time */
       if(timediff <= 0)
@@ -474,79 +474,79 @@ CURLcode Curl_resolver_wait_resolv(struct connectdata *conn,
         timeout = -1;
       else
         timeout -= timediff;
-      now = now2; /* for next loop */ 
-    } 
+      now = now2; /* for next loop */
+    }
     if(timeout < 0)
       result = CURLE_OPERATION_TIMEDOUT;
-  } 
+  }
   if(result)
     /* failure, so we cancel the ares operation */
     ares_cancel((ares_channel)data->state.resolver);
- 
-  /* Operation complete, if the lookup was successful we now have the entry 
-     in the cache. */ 
-  if(entry) 
-    *entry = conn->async.dns; 
- 
+
+  /* Operation complete, if the lookup was successful we now have the entry
+     in the cache. */
+  if(entry)
+    *entry = conn->async.dns;
+
   if(result)
-    /* close the connection, since we can't return failure here without 
+    /* close the connection, since we can't return failure here without
        cleaning up this connection properly. */
     connclose(conn, "c-ares resolve failed");
- 
+
   return result;
-} 
- 
-/* Connects results to the list */ 
+}
+
+/* Connects results to the list */
 static void compound_results(struct thread_data *res,
                              struct Curl_addrinfo *ai)
-{ 
+{
   struct Curl_addrinfo *ai_tail;
-  if(!ai) 
-    return; 
-  ai_tail = ai; 
- 
-  while(ai_tail->ai_next) 
-    ai_tail = ai_tail->ai_next; 
- 
-  /* Add the new results to the list of old results. */ 
-  ai_tail->ai_next = res->temp_ai; 
-  res->temp_ai = ai; 
-} 
- 
-/* 
- * ares_query_completed_cb() is the callback that ares will call when 
- * the host query initiated by ares_gethostbyname() from Curl_getaddrinfo(), 
- * when using ares, is completed either successfully or with failure. 
- */ 
-static void query_completed_cb(void *arg,  /* (struct connectdata *) */ 
-                               int status, 
-#ifdef HAVE_CARES_CALLBACK_TIMEOUTS 
-                               int timeouts, 
-#endif 
-                               struct hostent *hostent) 
-{ 
-  struct connectdata *conn = (struct connectdata *)arg; 
+  if(!ai)
+    return;
+  ai_tail = ai;
+
+  while(ai_tail->ai_next)
+    ai_tail = ai_tail->ai_next;
+
+  /* Add the new results to the list of old results. */
+  ai_tail->ai_next = res->temp_ai;
+  res->temp_ai = ai;
+}
+
+/*
+ * ares_query_completed_cb() is the callback that ares will call when
+ * the host query initiated by ares_gethostbyname() from Curl_getaddrinfo(),
+ * when using ares, is completed either successfully or with failure.
+ */
+static void query_completed_cb(void *arg,  /* (struct connectdata *) */
+                               int status,
+#ifdef HAVE_CARES_CALLBACK_TIMEOUTS
+                               int timeouts,
+#endif
+                               struct hostent *hostent)
+{
+  struct connectdata *conn = (struct connectdata *)arg;
   struct thread_data *res;
- 
-#ifdef HAVE_CARES_CALLBACK_TIMEOUTS 
-  (void)timeouts; /* ignored */ 
-#endif 
- 
-  if(ARES_EDESTRUCTION == status) 
-    /* when this ares handle is getting destroyed, the 'arg' pointer may not 
-       be valid so only defer it when we know the 'status' says its fine! */ 
-    return; 
- 
+
+#ifdef HAVE_CARES_CALLBACK_TIMEOUTS
+  (void)timeouts; /* ignored */
+#endif
+
+  if(ARES_EDESTRUCTION == status)
+    /* when this ares handle is getting destroyed, the 'arg' pointer may not
+       be valid so only defer it when we know the 'status' says its fine! */
+    return;
+
   res = conn->async.tdata;
   if(res) {
     res->num_pending--;
- 
+
     if(CURL_ASYNC_SUCCESS == status) {
       struct Curl_addrinfo *ai = Curl_he2ai(hostent, conn->async.port);
       if(ai) {
         compound_results(res, ai);
       }
-    } 
+    }
     /* A successful result overwrites any previous error */
     if(res->last_status != ARES_SUCCESS)
       res->last_status = status;
@@ -610,206 +610,206 @@ static void query_completed_cb(void *arg,  /* (struct connectdata *) */
       Curl_expire(
         conn->data, HAPPY_EYEBALLS_DNS_TIMEOUT, EXPIRE_HAPPY_EYEBALLS_DNS);
     }
-  } 
-} 
- 
-/* 
- * Curl_resolver_getaddrinfo() - when using ares 
- * 
- * Returns name information about the given hostname and port number. If 
- * successful, the 'hostent' is returned and the forth argument will point to 
- * memory we need to free after use. That memory *MUST* be freed with 
- * Curl_freeaddrinfo(), nothing else. 
- */ 
+  }
+}
+
+/*
+ * Curl_resolver_getaddrinfo() - when using ares
+ *
+ * Returns name information about the given hostname and port number. If
+ * successful, the 'hostent' is returned and the forth argument will point to
+ * memory we need to free after use. That memory *MUST* be freed with
+ * Curl_freeaddrinfo(), nothing else.
+ */
 struct Curl_addrinfo *Curl_resolver_getaddrinfo(struct connectdata *conn,
                                                 const char *hostname,
                                                 int port,
                                                 int *waitp)
-{ 
-  char *bufp; 
+{
+  char *bufp;
   struct Curl_easy *data = conn->data;
-  int family = PF_INET; 
- 
-  *waitp = 0; /* default to synchronous response */ 
- 
+  int family = PF_INET;
+
+  *waitp = 0; /* default to synchronous response */
+
 #ifdef ENABLE_IPV6
-  switch(conn->ip_version) { 
-  default: 
-#if ARES_VERSION >= 0x010601 
-    family = PF_UNSPEC; /* supported by c-ares since 1.6.1, so for older 
-                           c-ares versions this just falls through and defaults 
-                           to PF_INET */ 
-    break; 
-#endif 
-  case CURL_IPRESOLVE_V4: 
-    family = PF_INET; 
-    break; 
-  case CURL_IPRESOLVE_V6: 
-    family = PF_INET6; 
-    break; 
-  } 
+  switch(conn->ip_version) {
+  default:
+#if ARES_VERSION >= 0x010601
+    family = PF_UNSPEC; /* supported by c-ares since 1.6.1, so for older
+                           c-ares versions this just falls through and defaults
+                           to PF_INET */
+    break;
+#endif
+  case CURL_IPRESOLVE_V4:
+    family = PF_INET;
+    break;
+  case CURL_IPRESOLVE_V6:
+    family = PF_INET6;
+    break;
+  }
 #endif /* ENABLE_IPV6 */
- 
-  bufp = strdup(hostname); 
-  if(bufp) { 
+
+  bufp = strdup(hostname);
+  if(bufp) {
     struct thread_data *res = NULL;
     free(conn->async.hostname);
-    conn->async.hostname = bufp; 
-    conn->async.port = port; 
-    conn->async.done = FALSE;   /* not done */ 
-    conn->async.status = 0;     /* clear */ 
-    conn->async.dns = NULL;     /* clear */ 
+    conn->async.hostname = bufp;
+    conn->async.port = port;
+    conn->async.done = FALSE;   /* not done */
+    conn->async.status = 0;     /* clear */
+    conn->async.dns = NULL;     /* clear */
     res = calloc(sizeof(struct thread_data), 1);
-    if(!res) { 
+    if(!res) {
       free(conn->async.hostname);
-      conn->async.hostname = NULL; 
-      return NULL; 
-    } 
+      conn->async.hostname = NULL;
+      return NULL;
+    }
     conn->async.tdata = res;
- 
-    /* initial status - failed */ 
-    res->last_status = ARES_ENOTFOUND; 
+
+    /* initial status - failed */
+    res->last_status = ARES_ENOTFOUND;
 #ifdef ENABLE_IPV6
-    if(family == PF_UNSPEC) { 
+    if(family == PF_UNSPEC) {
       if(Curl_ipv6works(conn)) {
-        res->num_pending = 2; 
- 
-        /* areschannel is already setup in the Curl_open() function */ 
-        ares_gethostbyname((ares_channel)data->state.resolver, hostname, 
-                            PF_INET, query_completed_cb, conn); 
-        ares_gethostbyname((ares_channel)data->state.resolver, hostname, 
-                            PF_INET6, query_completed_cb, conn); 
-      } 
-      else { 
-        res->num_pending = 1; 
- 
-        /* areschannel is already setup in the Curl_open() function */ 
-        ares_gethostbyname((ares_channel)data->state.resolver, hostname, 
-                            PF_INET, query_completed_cb, conn); 
-      } 
-    } 
-    else 
+        res->num_pending = 2;
+
+        /* areschannel is already setup in the Curl_open() function */
+        ares_gethostbyname((ares_channel)data->state.resolver, hostname,
+                            PF_INET, query_completed_cb, conn);
+        ares_gethostbyname((ares_channel)data->state.resolver, hostname,
+                            PF_INET6, query_completed_cb, conn);
+      }
+      else {
+        res->num_pending = 1;
+
+        /* areschannel is already setup in the Curl_open() function */
+        ares_gethostbyname((ares_channel)data->state.resolver, hostname,
+                            PF_INET, query_completed_cb, conn);
+      }
+    }
+    else
 #endif /* ENABLE_IPV6 */
-    { 
-      res->num_pending = 1; 
- 
-      /* areschannel is already setup in the Curl_open() function */ 
-      ares_gethostbyname((ares_channel)data->state.resolver, hostname, family, 
-                         query_completed_cb, conn); 
-    } 
- 
-    *waitp = 1; /* expect asynchronous response */ 
-  } 
-  return NULL; /* no struct yet */ 
-} 
- 
+    {
+      res->num_pending = 1;
+
+      /* areschannel is already setup in the Curl_open() function */
+      ares_gethostbyname((ares_channel)data->state.resolver, hostname, family,
+                         query_completed_cb, conn);
+    }
+
+    *waitp = 1; /* expect asynchronous response */
+  }
+  return NULL; /* no struct yet */
+}
+
 CURLcode Curl_set_dns_servers(struct Curl_easy *data,
-                              char *servers) 
-{ 
-  CURLcode result = CURLE_NOT_BUILT_IN; 
-  int ares_result; 
- 
-  /* If server is NULL or empty, this would purge all DNS servers 
-   * from ares library, which will cause any and all queries to fail. 
-   * So, just return OK if none are configured and don't actually make 
-   * any changes to c-ares.  This lets c-ares use it's defaults, which 
-   * it gets from the OS (for instance from /etc/resolv.conf on Linux). 
-   */ 
-  if(!(servers && servers[0])) 
-    return CURLE_OK; 
- 
-#if (ARES_VERSION >= 0x010704) 
+                              char *servers)
+{
+  CURLcode result = CURLE_NOT_BUILT_IN;
+  int ares_result;
+
+  /* If server is NULL or empty, this would purge all DNS servers
+   * from ares library, which will cause any and all queries to fail.
+   * So, just return OK if none are configured and don't actually make
+   * any changes to c-ares.  This lets c-ares use it's defaults, which
+   * it gets from the OS (for instance from /etc/resolv.conf on Linux).
+   */
+  if(!(servers && servers[0]))
+    return CURLE_OK;
+
+#if (ARES_VERSION >= 0x010704)
 #if (ARES_VERSION >= 0x010b00)
   ares_result = ares_set_servers_ports_csv(data->state.resolver, servers);
 #else
-  ares_result = ares_set_servers_csv(data->state.resolver, servers); 
+  ares_result = ares_set_servers_csv(data->state.resolver, servers);
 #endif
-  switch(ares_result) { 
-  case ARES_SUCCESS: 
-    result = CURLE_OK; 
-    break; 
-  case ARES_ENOMEM: 
-    result = CURLE_OUT_OF_MEMORY; 
-    break; 
-  case ARES_ENOTINITIALIZED: 
-  case ARES_ENODATA: 
-  case ARES_EBADSTR: 
-  default: 
-    result = CURLE_BAD_FUNCTION_ARGUMENT; 
-    break; 
-  } 
-#else /* too old c-ares version! */ 
-  (void)data; 
-  (void)(ares_result); 
-#endif 
-  return result; 
-} 
- 
+  switch(ares_result) {
+  case ARES_SUCCESS:
+    result = CURLE_OK;
+    break;
+  case ARES_ENOMEM:
+    result = CURLE_OUT_OF_MEMORY;
+    break;
+  case ARES_ENOTINITIALIZED:
+  case ARES_ENODATA:
+  case ARES_EBADSTR:
+  default:
+    result = CURLE_BAD_FUNCTION_ARGUMENT;
+    break;
+  }
+#else /* too old c-ares version! */
+  (void)data;
+  (void)(ares_result);
+#endif
+  return result;
+}
+
 CURLcode Curl_set_dns_interface(struct Curl_easy *data,
-                                const char *interf) 
-{ 
-#if (ARES_VERSION >= 0x010704) 
-  if(!interf) 
-    interf = ""; 
- 
-  ares_set_local_dev((ares_channel)data->state.resolver, interf); 
- 
-  return CURLE_OK; 
-#else /* c-ares version too old! */ 
-  (void)data; 
-  (void)interf; 
-  return CURLE_NOT_BUILT_IN; 
-#endif 
-} 
- 
+                                const char *interf)
+{
+#if (ARES_VERSION >= 0x010704)
+  if(!interf)
+    interf = "";
+
+  ares_set_local_dev((ares_channel)data->state.resolver, interf);
+
+  return CURLE_OK;
+#else /* c-ares version too old! */
+  (void)data;
+  (void)interf;
+  return CURLE_NOT_BUILT_IN;
+#endif
+}
+
 CURLcode Curl_set_dns_local_ip4(struct Curl_easy *data,
-                                const char *local_ip4) 
-{ 
-#if (ARES_VERSION >= 0x010704) 
+                                const char *local_ip4)
+{
+#if (ARES_VERSION >= 0x010704)
   struct in_addr a4;
- 
-  if((!local_ip4) || (local_ip4[0] == 0)) { 
+
+  if((!local_ip4) || (local_ip4[0] == 0)) {
     a4.s_addr = 0; /* disabled: do not bind to a specific address */
-  } 
-  else { 
-    if(Curl_inet_pton(AF_INET, local_ip4, &a4) != 1) { 
-      return CURLE_BAD_FUNCTION_ARGUMENT; 
-    } 
-  } 
- 
+  }
+  else {
+    if(Curl_inet_pton(AF_INET, local_ip4, &a4) != 1) {
+      return CURLE_BAD_FUNCTION_ARGUMENT;
+    }
+  }
+
   ares_set_local_ip4((ares_channel)data->state.resolver, ntohl(a4.s_addr));
- 
-  return CURLE_OK; 
-#else /* c-ares version too old! */ 
-  (void)data; 
-  (void)local_ip4; 
-  return CURLE_NOT_BUILT_IN; 
-#endif 
-} 
- 
+
+  return CURLE_OK;
+#else /* c-ares version too old! */
+  (void)data;
+  (void)local_ip4;
+  return CURLE_NOT_BUILT_IN;
+#endif
+}
+
 CURLcode Curl_set_dns_local_ip6(struct Curl_easy *data,
-                                const char *local_ip6) 
-{ 
+                                const char *local_ip6)
+{
 #if (ARES_VERSION >= 0x010704) && defined(ENABLE_IPV6)
-  unsigned char a6[INET6_ADDRSTRLEN]; 
- 
-  if((!local_ip6) || (local_ip6[0] == 0)) { 
-    /* disabled: do not bind to a specific address */ 
-    memset(a6, 0, sizeof(a6)); 
-  } 
-  else { 
-    if(Curl_inet_pton(AF_INET6, local_ip6, a6) != 1) { 
-      return CURLE_BAD_FUNCTION_ARGUMENT; 
-    } 
-  } 
- 
-  ares_set_local_ip6((ares_channel)data->state.resolver, a6); 
- 
-  return CURLE_OK; 
-#else /* c-ares version too old! */ 
-  (void)data; 
-  (void)local_ip6; 
-  return CURLE_NOT_BUILT_IN; 
-#endif 
-} 
-#endif /* CURLRES_ARES */ 
+  unsigned char a6[INET6_ADDRSTRLEN];
+
+  if((!local_ip6) || (local_ip6[0] == 0)) {
+    /* disabled: do not bind to a specific address */
+    memset(a6, 0, sizeof(a6));
+  }
+  else {
+    if(Curl_inet_pton(AF_INET6, local_ip6, a6) != 1) {
+      return CURLE_BAD_FUNCTION_ARGUMENT;
+    }
+  }
+
+  ares_set_local_ip6((ares_channel)data->state.resolver, a6);
+
+  return CURLE_OK;
+#else /* c-ares version too old! */
+  (void)data;
+  (void)local_ip6;
+  return CURLE_NOT_BUILT_IN;
+#endif
+}
+#endif /* CURLRES_ARES */