lib/asyn-ares.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
   9  *
  10  * This software is licensed as described in the file COPYING, which
  11  * you should have received as part of this distribution. The terms
  12  * are also available at https://curl.haxx.se/docs/copyright.html.
  13  *
  14  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15  * copies of the Software, and permit persons to whom the Software is
  16  * furnished to do so, under the terms of the COPYING file.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ***************************************************************************/
  22
  23 #include "curl_setup.h"
  24
  25 #ifdef HAVE_LIMITS_H
  26 #include <limits.h>
  27 #endif
  28 #ifdef HAVE_NETINET_IN_H
  29 #include <netinet/in.h>
  30 #endif
  31 #ifdef HAVE_NETDB_H
  32 #include <netdb.h>
  33 #endif
  34 #ifdef HAVE_ARPA_INET_H
  35 #include <arpa/inet.h>
  36 #endif
  37 #ifdef __VMS
  38 #include <in.h>
  39 #include <inet.h>
  40 #endif
  41
  42 #ifdef HAVE_PROCESS_H
  43 #include <process.h>
  44 #endif
  45
  46 #if (defined(NETWARE) && defined(__NOVELL_LIBC__))
  47 #undef in_addr_t
  48 #define in_addr_t unsigned long
  49 #endif
  50
  51 /***********************************************************************
  52  * Only for ares-enabled builds
  53  * And only for functions that fulfill the asynch resolver backend API
  54  * as defined in asyn.h, nothing else belongs in this file!
  55  **********************************************************************/
  56
  57 #ifdef CURLRES_ARES
  58
  59 #include "urldata.h"
  60 #include "sendf.h"
  61 #include "hostip.h"
  62 #include "hash.h"
  63 #include "share.h"
  64 #include "strerror.h"
  65 #include "url.h"
  66 #include "multiif.h"
  67 #include "inet_pton.h"
  68 #include "connect.h"
  69 #include "select.h"
  70 #include "progress.h"
  71
  72 #  if defined(CURL_STATICLIB) && !defined(CARES_STATICLIB) && \
  73      (defined(WIN32) || defined(_WIN32) || defined(__SYMBIAN32__))
  74 #    define CARES_STATICLIB
  75 #  endif
  76 #  include <ares.h>
  77 #  include <ares_version.h> /* really old c-ares didn't include this by
  78                                itself */
  79
  80 #if ARES_VERSION >= 0x010500
  81 /* c-ares 1.5.0 or later, the callback proto is modified */
  82 #define HAVE_CARES_CALLBACK_TIMEOUTS 1
  83 #endif
  84
  85 /* The last 3 #include files should be in this order */
  86 #include "curl_printf.h"
  87 #include "curl_memory.h"
  88 #include "memdebug.h"
  89
  90 struct ResolverResults {
  91   int num_pending; /* number of ares_gethostbyname() requests */
  92   Curl_addrinfo *temp_ai; /* intermediary result while fetching c-ares parts */
  93   int last_status;
  94 };
  95
  96 /*
  97  * Curl_resolver_global_init() - the generic low-level asynchronous name
  98  * resolve API.  Called from curl_global_init() to initialize global resolver
  99  * environment.  Initializes ares library.
 100  */
 101 int Curl_resolver_global_init(void)
 102 {
 103 #ifdef CARES_HAVE_ARES_LIBRARY_INIT
 104   if(ares_library_init(ARES_LIB_INIT_ALL)) {
 105     return CURLE_FAILED_INIT;
 106   }
 107 #endif
 108   return CURLE_OK;
 109 }
 110
 111 /*
 112  * Curl_resolver_global_cleanup()
 113  *
 114  * Called from curl_global_cleanup() to destroy global resolver environment.
 115  * Deinitializes ares library.
 116  */
 117 void Curl_resolver_global_cleanup(void)
 118 {
 119 #ifdef CARES_HAVE_ARES_LIBRARY_CLEANUP
 120   ares_library_cleanup();
 121 #endif
 122 }
 123
 124 /*
 125  * Curl_resolver_init()
 126  *
 127  * Called from curl_easy_init() -> Curl_open() to initialize resolver
 128  * URL-state specific environment ('resolver' member of the UrlState
 129  * structure).  Fills the passed pointer by the initialized ares_channel.
 130  */
 131 CURLcode Curl_resolver_init(void **resolver)
 132 {
 133   int status = ares_init((ares_channel*)resolver);
 134   if(status != ARES_SUCCESS) {
 135     if(status == ARES_ENOMEM)
 136       return CURLE_OUT_OF_MEMORY;
 137     else
 138       return CURLE_FAILED_INIT;
 139   }
 140   return CURLE_OK;
 141   /* make sure that all other returns from this function should destroy the
 142      ares channel before returning error! */
 143 }
 144
 145 /*
 146  * Curl_resolver_cleanup()
 147  *
 148  * Called from curl_easy_cleanup() -> Curl_close() to cleanup resolver
 149  * URL-state specific environment ('resolver' member of the UrlState
 150  * structure).  Destroys the ares channel.
 151  */
 152 void Curl_resolver_cleanup(void *resolver)
 153 {
 154   ares_destroy((ares_channel)resolver);
 155 }
 156
 157 /*
 158  * Curl_resolver_duphandle()
 159  *
 160  * Called from curl_easy_duphandle() to duplicate resolver URL-state specific
 161  * environment ('resolver' member of the UrlState structure).  Duplicates the
 162  * 'from' ares channel and passes the resulting channel to the 'to' pointer.
 163  */
 164 int Curl_resolver_duphandle(void **to, void *from)
 165 {
 166   /* Clone the ares channel for the new handle */
 167   if(ARES_SUCCESS != ares_dup((ares_channel*)to, (ares_channel)from))
 168     return CURLE_FAILED_INIT;
 169   return CURLE_OK;
 170 }
 171
 172 static void destroy_async_data(struct Curl_async *async);
 173
 174 /*
 175  * Cancel all possibly still on-going resolves for this connection.
 176  */
 177 void Curl_resolver_cancel(struct connectdata *conn)
 178 {
 179   if(conn->data && conn->data->state.resolver)
 180     ares_cancel((ares_channel)conn->data->state.resolver);
 181   destroy_async_data(&conn->async);
 182 }
 183
 184 /*
 185  * destroy_async_data() cleans up async resolver data.
 186  */
 187 static void destroy_async_data(struct Curl_async *async)
 188 {
 189   free(async->hostname);
 190
 191   if(async->os_specific) {
 192     struct ResolverResults *res = (struct ResolverResults *)async->os_specific;
 193     if(res) {
 194       if(res->temp_ai) {
 195         Curl_freeaddrinfo(res->temp_ai);
 196         res->temp_ai = NULL;
 197       }
 198       free(res);
 199     }
 200     async->os_specific = NULL;
 201   }
 202
 203   async->hostname = NULL;
 204 }
 205
 206 /*
 207  * Curl_resolver_getsock() is called when someone from the outside world
 208  * (using curl_multi_fdset()) wants to get our fd_set setup and we're talking
 209  * with ares. The caller must make sure that this function is only called when
 210  * we have a working ares channel.
 211  *
 212  * Returns: sockets-in-use-bitmap
 213  */
 214
 215 int Curl_resolver_getsock(struct connectdata *conn,
 216                           curl_socket_t *socks,
 217                           int numsocks)
 218
 219 {
 220   struct timeval maxtime;
 221   struct timeval timebuf;
 222   struct timeval *timeout;
 223   long milli;
 224   int max = ares_getsock((ares_channel)conn->data->state.resolver,
 225                          (ares_socket_t *)socks, numsocks);
 226
 227   maxtime.tv_sec = CURL_TIMEOUT_RESOLVE;
 228   maxtime.tv_usec = 0;
 229
 230   timeout = ares_timeout((ares_channel)conn->data->state.resolver, &maxtime,
 231                          &timebuf);
 232   milli = (timeout->tv_sec * 1000) + (timeout->tv_usec/1000);
 233   if(milli == 0)
 234     milli += 10;
 235   Curl_expire_latest(conn->data, milli);
 236
 237   return max;
 238 }
 239
 240 /*
 241  * waitperform()
 242  *
 243  * 1) Ask ares what sockets it currently plays with, then
 244  * 2) wait for the timeout period to check for action on ares' sockets.
 245  * 3) tell ares to act on all the sockets marked as "with action"
 246  *
 247  * return number of sockets it worked on
 248  */
 249
 250 static int waitperform(struct connectdata *conn, int timeout_ms)
 251 {
 252   struct Curl_easy *data = conn->data;
 253   int nfds;
 254   int bitmask;
 255   ares_socket_t socks[ARES_GETSOCK_MAXNUM];
 256   struct pollfd pfd[ARES_GETSOCK_MAXNUM];
 257   int i;
 258   int num = 0;
 259
 260   bitmask = ares_getsock((ares_channel)data->state.resolver, socks,
 261                          ARES_GETSOCK_MAXNUM);
 262
 263   for(i=0; i < ARES_GETSOCK_MAXNUM; i++) {
 264     pfd[i].events = 0;
 265     pfd[i].revents = 0;
 266     if(ARES_GETSOCK_READABLE(bitmask, i)) {
 267       pfd[i].fd = socks[i];
 268       pfd[i].events |= POLLRDNORM|POLLIN;
 269     }
 270     if(ARES_GETSOCK_WRITABLE(bitmask, i)) {
 271       pfd[i].fd = socks[i];
 272       pfd[i].events |= POLLWRNORM|POLLOUT;
 273     }
 274     if(pfd[i].events != 0)
 275       num++;
 276     else
 277       break;
 278   }
 279
 280   if(num)
 281     nfds = Curl_poll(pfd, num, timeout_ms);
 282   else
 283     nfds = 0;
 284
 285   if(!nfds)
 286     /* Call ares_process() unconditonally here, even if we simply timed out
 287        above, as otherwise the ares name resolve won't timeout! */
 288     ares_process_fd((ares_channel)data->state.resolver, ARES_SOCKET_BAD,
 289                     ARES_SOCKET_BAD);
 290   else {
 291     /* move through the descriptors and ask for processing on them */
 292     for(i=0; i < num; i++)
 293       ares_process_fd((ares_channel)data->state.resolver,
 294                       pfd[i].revents & (POLLRDNORM|POLLIN)?
 295                       pfd[i].fd:ARES_SOCKET_BAD,
 296                       pfd[i].revents & (POLLWRNORM|POLLOUT)?
 297                       pfd[i].fd:ARES_SOCKET_BAD);
 298   }
 299   return nfds;
 300 }
 301
 302 /*
 303  * Curl_resolver_is_resolved() is called repeatedly to check if a previous
 304  * name resolve request has completed. It should also make sure to time-out if
 305  * the operation seems to take too long.
 306  *
 307  * Returns normal CURLcode errors.
 308  */
 309 CURLcode Curl_resolver_is_resolved(struct connectdata *conn,
 310                                    struct Curl_dns_entry **dns)
 311 {
 312   struct Curl_easy *data = conn->data;
 313   struct ResolverResults *res = (struct ResolverResults *)
 314     conn->async.os_specific;
 315   CURLcode result = CURLE_OK;
 316
 317   *dns = NULL;
 318
 319   waitperform(conn, 0);
 320
 321   if(res && !res->num_pending) {
 322     (void)Curl_addrinfo_callback(conn, res->last_status, res->temp_ai);
 323     /* temp_ai ownership is moved to the connection, so we need not free-up
 324        them */
 325     res->temp_ai = NULL;
 326     if(!conn->async.dns) {
 327       failf(data, "Could not resolve: %s (%s)",
 328             conn->async.hostname, ares_strerror(conn->async.status));
 329       result = conn->bits.proxy?CURLE_COULDNT_RESOLVE_PROXY:
 330         CURLE_COULDNT_RESOLVE_HOST;
 331     }
 332     else
 333       *dns = conn->async.dns;
 334
 335     destroy_async_data(&conn->async);
 336   }
 337
 338   return result;
 339 }
 340
 341 /*
 342  * Curl_resolver_wait_resolv()
 343  *
 344  * waits for a resolve to finish. This function should be avoided since using
 345  * this risk getting the multi interface to "hang".
 346  *
 347  * If 'entry' is non-NULL, make it point to the resolved dns entry
 348  *
 349  * Returns CURLE_COULDNT_RESOLVE_HOST if the host was not resolved, and
 350  * CURLE_OPERATION_TIMEDOUT if a time-out occurred.
 351  */
 352 CURLcode Curl_resolver_wait_resolv(struct connectdata *conn,
 353                                    struct Curl_dns_entry **entry)
 354 {
 355   CURLcode result = CURLE_OK;
 356   struct Curl_easy *data = conn->data;
 357   long timeout;
 358   struct timeval now = Curl_tvnow();
 359   struct Curl_dns_entry *temp_entry;
 360
 361   timeout = Curl_timeleft(data, &now, TRUE);
 362   if(!timeout)
 363     timeout = CURL_TIMEOUT_RESOLVE * 1000; /* default name resolve timeout */
 364
 365   /* Wait for the name resolve query to complete. */
 366   for(;;) {
 367     struct timeval *tvp, tv, store;
 368     long timediff;
 369     int itimeout;
 370     int timeout_ms;
 371
 372     itimeout = (timeout > (long)INT_MAX) ? INT_MAX : (int)timeout;
 373
 374     store.tv_sec = itimeout/1000;
 375     store.tv_usec = (itimeout%1000)*1000;
 376
 377     tvp = ares_timeout((ares_channel)data->state.resolver, &store, &tv);
 378
 379     /* use the timeout period ares returned to us above if less than one
 380        second is left, otherwise just use 1000ms to make sure the progress
 381        callback gets called frequent enough */
 382     if(!tvp->tv_sec)
 383       timeout_ms = (int)(tvp->tv_usec/1000);
 384     else
 385       timeout_ms = 1000;
 386
 387     waitperform(conn, timeout_ms);
 388     Curl_resolver_is_resolved(conn, &temp_entry);
 389
 390     if(conn->async.done)
 391       break;
 392
 393     if(Curl_pgrsUpdate(conn)) {
 394       result = CURLE_ABORTED_BY_CALLBACK;
 395       timeout = -1; /* trigger the cancel below */
 396     }
 397     else {
 398       struct timeval now2 = Curl_tvnow();
 399       timediff = Curl_tvdiff(now2, now); /* spent time */
 400       timeout -= timediff?timediff:1; /* always deduct at least 1 */
 401       now = now2; /* for next loop */
 402     }
 403
 404     if(timeout < 0) {
 405       /* our timeout, so we cancel the ares operation */
 406       ares_cancel((ares_channel)data->state.resolver);
 407       break;
 408     }
 409   }
 410
 411   /* Operation complete, if the lookup was successful we now have the entry
 412      in the cache. */
 413   if(entry)
 414     *entry = conn->async.dns;
 415
 416   if(result)
 417     /* close the connection, since we can't return failure here without
 418        cleaning up this connection properly.
 419        TODO: remove this action from here, it is not a name resolver decision.
 420     */
 421     connclose(conn, "c-ares resolve failed");
 422
 423   return result;
 424 }
 425
 426 /* Connects results to the list */
 427 static void compound_results(struct ResolverResults *res,
 428                              Curl_addrinfo *ai)
 429 {
 430   Curl_addrinfo *ai_tail;
 431   if(!ai)
 432     return;
 433   ai_tail = ai;
 434
 435   while(ai_tail->ai_next)
 436     ai_tail = ai_tail->ai_next;
 437
 438   /* Add the new results to the list of old results. */
 439   ai_tail->ai_next = res->temp_ai;
 440   res->temp_ai = ai;
 441 }
 442
 443 /*
 444  * ares_query_completed_cb() is the callback that ares will call when
 445  * the host query initiated by ares_gethostbyname() from Curl_getaddrinfo(),
 446  * when using ares, is completed either successfully or with failure.
 447  */
 448 static void query_completed_cb(void *arg,  /* (struct connectdata *) */
 449                                int status,
 450 #ifdef HAVE_CARES_CALLBACK_TIMEOUTS
 451                                int timeouts,
 452 #endif
 453                                struct hostent *hostent)
 454 {
 455   struct connectdata *conn = (struct connectdata *)arg;
 456   struct ResolverResults *res;
 457
 458 #ifdef HAVE_CARES_CALLBACK_TIMEOUTS
 459   (void)timeouts; /* ignored */
 460 #endif
 461
 462   if(ARES_EDESTRUCTION == status)
 463     /* when this ares handle is getting destroyed, the 'arg' pointer may not
 464        be valid so only defer it when we know the 'status' says its fine! */
 465     return;
 466
 467   res = (struct ResolverResults *)conn->async.os_specific;
 468   res->num_pending--;
 469
 470   if(CURL_ASYNC_SUCCESS == status) {
 471     Curl_addrinfo *ai = Curl_he2ai(hostent, conn->async.port);
 472     if(ai) {
 473       compound_results(res, ai);
 474     }
 475   }
 476   /* A successful result overwrites any previous error */
 477   if(res->last_status != ARES_SUCCESS)
 478     res->last_status = status;
 479 }
 480
 481 /*
 482  * Curl_resolver_getaddrinfo() - when using ares
 483  *
 484  * Returns name information about the given hostname and port number. If
 485  * successful, the 'hostent' is returned and the forth argument will point to
 486  * memory we need to free after use. That memory *MUST* be freed with
 487  * Curl_freeaddrinfo(), nothing else.
 488  */
 489 Curl_addrinfo *Curl_resolver_getaddrinfo(struct connectdata *conn,
 490                                          const char *hostname,
 491                                          int port,
 492                                          int *waitp)
 493 {
 494   char *bufp;
 495   struct Curl_easy *data = conn->data;
 496   struct in_addr in;
 497   int family = PF_INET;
 498 #ifdef ENABLE_IPV6 /* CURLRES_IPV6 */
 499   struct in6_addr in6;
 500 #endif /* CURLRES_IPV6 */
 501
 502   *waitp = 0; /* default to synchronous response */
 503
 504   /* First check if this is an IPv4 address string */
 505   if(Curl_inet_pton(AF_INET, hostname, &in) > 0) {
 506     /* This is a dotted IP address 123.123.123.123-style */
 507     return Curl_ip2addr(AF_INET, &in, hostname, port);
 508   }
 509
 510 #ifdef ENABLE_IPV6 /* CURLRES_IPV6 */
 511   /* Otherwise, check if this is an IPv6 address string */
 512   if(Curl_inet_pton (AF_INET6, hostname, &in6) > 0)
 513     /* This must be an IPv6 address literal.  */
 514     return Curl_ip2addr(AF_INET6, &in6, hostname, port);
 515
 516   switch(conn->ip_version) {
 517   default:
 518 #if ARES_VERSION >= 0x010601
 519     family = PF_UNSPEC; /* supported by c-ares since 1.6.1, so for older
 520                            c-ares versions this just falls through and defaults
 521                            to PF_INET */
 522     break;
 523 #endif
 524   case CURL_IPRESOLVE_V4:
 525     family = PF_INET;
 526     break;
 527   case CURL_IPRESOLVE_V6:
 528     family = PF_INET6;
 529     break;
 530   }
 531 #endif /* CURLRES_IPV6 */
 532
 533   bufp = strdup(hostname);
 534   if(bufp) {
 535     struct ResolverResults *res = NULL;
 536     free(conn->async.hostname);
 537     conn->async.hostname = bufp;
 538     conn->async.port = port;
 539     conn->async.done = FALSE;   /* not done */
 540     conn->async.status = 0;     /* clear */
 541     conn->async.dns = NULL;     /* clear */
 542     res = calloc(sizeof(struct ResolverResults), 1);
 543     if(!res) {
 544       free(conn->async.hostname);
 545       conn->async.hostname = NULL;
 546       return NULL;
 547     }
 548     conn->async.os_specific = res;
 549
 550     /* initial status - failed */
 551     res->last_status = ARES_ENOTFOUND;
 552 #ifdef ENABLE_IPV6 /* CURLRES_IPV6 */
 553     if(family == PF_UNSPEC) {
 554       if(Curl_ipv6works()) {
 555         res->num_pending = 2;
 556
 557         /* areschannel is already setup in the Curl_open() function */
 558         ares_gethostbyname((ares_channel)data->state.resolver, hostname,
 559                             PF_INET, query_completed_cb, conn);
 560         ares_gethostbyname((ares_channel)data->state.resolver, hostname,
 561                             PF_INET6, query_completed_cb, conn);
 562       }
 563       else {
 564         res->num_pending = 1;
 565
 566         /* areschannel is already setup in the Curl_open() function */
 567         ares_gethostbyname((ares_channel)data->state.resolver, hostname,
 568                             PF_INET, query_completed_cb, conn);
 569       }
 570     }
 571     else
 572 #endif /* CURLRES_IPV6 */
 573     {
 574       res->num_pending = 1;
 575
 576       /* areschannel is already setup in the Curl_open() function */
 577       ares_gethostbyname((ares_channel)data->state.resolver, hostname, family,
 578                          query_completed_cb, conn);
 579     }
 580
 581     *waitp = 1; /* expect asynchronous response */
 582   }
 583   return NULL; /* no struct yet */
 584 }
 585
 586 CURLcode Curl_set_dns_servers(struct Curl_easy *data,
 587                               char *servers)
 588 {
 589   CURLcode result = CURLE_NOT_BUILT_IN;
 590   int ares_result;
 591
 592   /* If server is NULL or empty, this would purge all DNS servers
 593    * from ares library, which will cause any and all queries to fail.
 594    * So, just return OK if none are configured and don't actually make
 595    * any changes to c-ares.  This lets c-ares use it's defaults, which
 596    * it gets from the OS (for instance from /etc/resolv.conf on Linux).
 597    */
 598   if(!(servers && servers[0]))
 599     return CURLE_OK;
 600
 601 #if (ARES_VERSION >= 0x010704)
 602   ares_result = ares_set_servers_csv(data->state.resolver, servers);
 603   switch(ares_result) {
 604   case ARES_SUCCESS:
 605     result = CURLE_OK;
 606     break;
 607   case ARES_ENOMEM:
 608     result = CURLE_OUT_OF_MEMORY;
 609     break;
 610   case ARES_ENOTINITIALIZED:
 611   case ARES_ENODATA:
 612   case ARES_EBADSTR:
 613   default:
 614     result = CURLE_BAD_FUNCTION_ARGUMENT;
 615     break;
 616   }
 617 #else /* too old c-ares version! */
 618   (void)data;
 619   (void)(ares_result);
 620 #endif
 621   return result;
 622 }
 623
 624 CURLcode Curl_set_dns_interface(struct Curl_easy *data,
 625                                 const char *interf)
 626 {
 627 #if (ARES_VERSION >= 0x010704)
 628   if(!interf)
 629     interf = "";
 630
 631   ares_set_local_dev((ares_channel)data->state.resolver, interf);
 632
 633   return CURLE_OK;
 634 #else /* c-ares version too old! */
 635   (void)data;
 636   (void)interf;
 637   return CURLE_NOT_BUILT_IN;
 638 #endif
 639 }
 640
 641 CURLcode Curl_set_dns_local_ip4(struct Curl_easy *data,
 642                                 const char *local_ip4)
 643 {
 644 #if (ARES_VERSION >= 0x010704)
 645   struct in_addr a4;
 646
 647   if((!local_ip4) || (local_ip4[0] == 0)) {
 648     a4.s_addr = 0; /* disabled: do not bind to a specific address */
 649   }
 650   else {
 651     if(Curl_inet_pton(AF_INET, local_ip4, &a4) != 1) {
 652       return CURLE_BAD_FUNCTION_ARGUMENT;
 653     }
 654   }
 655
 656   ares_set_local_ip4((ares_channel)data->state.resolver, ntohl(a4.s_addr));
 657
 658   return CURLE_OK;
 659 #else /* c-ares version too old! */
 660   (void)data;
 661   (void)local_ip4;
 662   return CURLE_NOT_BUILT_IN;
 663 #endif
 664 }
 665
 666 CURLcode Curl_set_dns_local_ip6(struct Curl_easy *data,
 667                                 const char *local_ip6)
 668 {
 669 #if (ARES_VERSION >= 0x010704) && defined(ENABLE_IPV6)
 670   unsigned char a6[INET6_ADDRSTRLEN];
 671
 672   if((!local_ip6) || (local_ip6[0] == 0)) {
 673     /* disabled: do not bind to a specific address */
 674     memset(a6, 0, sizeof(a6));
 675   }
 676   else {
 677     if(Curl_inet_pton(AF_INET6, local_ip6, a6) != 1) {
 678       return CURLE_BAD_FUNCTION_ARGUMENT;
 679     }
 680   }
 681
 682   ares_set_local_ip6((ares_channel)data->state.resolver, a6);
 683
 684   return CURLE_OK;
 685 #else /* c-ares version too old! */
 686   (void)data;
 687   (void)local_ip6;
 688   return CURLE_NOT_BUILT_IN;
 689 #endif
 690 }
 691 #endif /* CURLRES_ARES */