/***************************************************************************
 *                                  _   _ ____  _
 *  Project                     ___| | | |  _ \| |
 *                             / __| | | | |_) | |
 *                            | (__| |_| |  _ <| |___
 *                             \___|\___/|_| \_\_____|
 *
 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
 *
 * This software is licensed as described in the file COPYING, which
 * you should have received as part of this distribution. The terms
 * are also available at https://curl.se/docs/copyright.html.
 *
 * 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.
 *
 * SPDX-License-Identifier: curl
 *
 ***************************************************************************/

#include "curl_setup.h"

#ifdef CURLRES_ARES

/***********************************************************************
 * 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!
 **********************************************************************/

#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

#include "urldata.h"
#include "cfilters.h"
#include "sendf.h"
#include "hostip.h"
#include "hash.h"
#include "share.h"
#include "url.h"
#include "multiif.h"
#include "curlx/inet_pton.h"
#include "connect.h"
#include "select.h"
#include "progress.h"
#include "curlx/timediff.h"
#include "httpsrr.h"

#include <ares.h>
#include <ares_version.h> /* really old c-ares did not include this by
                             itself */

#if ARES_VERSION >= 0x010601
/* IPv6 supported since 1.6.1 */
#define HAVE_CARES_IPV6 1
#endif

#if ARES_VERSION >= 0x010704
#define HAVE_CARES_SERVERS_CSV 1
#define HAVE_CARES_LOCAL_DEV 1
#define HAVE_CARES_SET_LOCAL 1
#endif

#if ARES_VERSION >= 0x010b00
#define HAVE_CARES_PORTS_CSV 1
#endif

#if ARES_VERSION >= 0x011000
/* 1.16.0 or later has ares_getaddrinfo */
#define HAVE_CARES_GETADDRINFO 1
#else
/* How long we are willing to wait for additional parallel responses after
   obtaining a "definitive" one. For old c-ares without getaddrinfo.

   This is intended to equal the c-ares default timeout. cURL always uses that
   default value. Unfortunately, c-ares does not expose its default timeout in
   its API, but it is officially documented as 5 seconds.

   See query_completed_cb() for an explanation of how this is used.
 */
#define HAPPY_EYEBALLS_DNS_TIMEOUT 5000
#endif

#ifdef USE_HTTPSRR
#if ARES_VERSION < 0x011c00
#error "requires c-ares 1.28.0 or newer for HTTPSRR"
#endif
#define HTTPSRR_WORKS
#endif

/* The last 2 #include files should be in this order */
#include "curl_memory.h"
#include "memdebug.h"

#define CARES_TIMEOUT_PER_ATTEMPT 2000

static int ares_ver = 0;

static CURLcode async_ares_set_dns_servers(struct Curl_easy *data,
                                           bool reset_on_null);

/*
 * Curl_async_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_async_global_init(void)
{
#ifdef CARES_HAVE_ARES_LIBRARY_INIT
  if(ares_library_init(ARES_LIB_INIT_ALL)) {
    return CURLE_FAILED_INIT;
  }
#endif
  ares_version(&ares_ver);
  return CURLE_OK;
}

/*
 * Curl_async_global_cleanup()
 *
 * Called from curl_global_cleanup() to destroy global resolver environment.
 * Deinitializes ares library.
 */
void Curl_async_global_cleanup(void)
{
#ifdef CARES_HAVE_ARES_LIBRARY_CLEANUP
  ares_library_cleanup();
#endif
}


static void sock_state_cb(void *data, ares_socket_t socket_fd,
                          int readable, int writable)
{
  struct Curl_easy *easy = data;
  if(!readable && !writable) {
    DEBUGASSERT(easy);
    Curl_multi_will_close(easy, socket_fd);
  }
}

static CURLcode async_ares_init(struct Curl_easy *data)
{
  struct async_ares_ctx *ares = &data->state.async.ares;
  int status;
  struct ares_options options;
  int optmask = ARES_OPT_SOCK_STATE_CB;
  CURLcode rc = CURLE_OK;

  options.sock_state_cb = sock_state_cb;
  options.sock_state_cb_data = data;

  DEBUGASSERT(!ares->channel);
  /*
     if c ares < 1.20.0: curl set timeout to CARES_TIMEOUT_PER_ATTEMPT (2s)

     if c-ares >= 1.20.0 it already has the timeout to 2s, curl does not need
     to set the timeout value;

     if c-ares >= 1.24.0, user can set the timeout via /etc/resolv.conf to
     overwrite c-ares' timeout.
  */
  DEBUGASSERT(ares_ver);
  if(ares_ver < 0x011400) {
    options.timeout = CARES_TIMEOUT_PER_ATTEMPT;
    optmask |= ARES_OPT_TIMEOUTMS;
  }

  status = ares_init_options(&ares->channel, &options, optmask);
  if(status != ARES_SUCCESS) {
    ares->channel = NULL;
    rc = (status == ARES_ENOMEM) ?
         CURLE_OUT_OF_MEMORY : CURLE_FAILED_INIT;
    goto out;
  }

  rc = async_ares_set_dns_servers(data, FALSE);
  if(rc && rc != CURLE_NOT_BUILT_IN)
    goto out;

  rc = Curl_async_ares_set_dns_interface(data);
  if(rc && rc != CURLE_NOT_BUILT_IN)
    goto out;

  rc = Curl_async_ares_set_dns_local_ip4(data);
  if(rc && rc != CURLE_NOT_BUILT_IN)
    goto out;

  rc = Curl_async_ares_set_dns_local_ip6(data);
  if(rc && rc != CURLE_NOT_BUILT_IN)
    goto out;

  rc = CURLE_OK;

out:
  if(rc && ares->channel) {
    ares_destroy(ares->channel);
    ares->channel = NULL;
  }
  return rc;
}

static CURLcode async_ares_init_lazy(struct Curl_easy *data)
{
  struct async_ares_ctx *ares = &data->state.async.ares;
  if(!ares->channel)
    return async_ares_init(data);
  return CURLE_OK;
}

CURLcode Curl_async_get_impl(struct Curl_easy *data, void **impl)
{
  struct async_ares_ctx *ares = &data->state.async.ares;
  CURLcode result = CURLE_OK;
  if(!ares->channel) {
    result = async_ares_init(data);
  }
  *impl = ares->channel;
  return result;
}

/*
 * async_ares_cleanup() cleans up async resolver data.
 */
static void async_ares_cleanup(struct Curl_easy *data)
{
  struct async_ares_ctx *ares = &data->state.async.ares;
  if(ares->temp_ai) {
    Curl_freeaddrinfo(ares->temp_ai);
    ares->temp_ai = NULL;
  }
#ifdef USE_HTTPSRR
  Curl_httpsrr_cleanup(&ares->hinfo);
#endif
}

void Curl_async_ares_shutdown(struct Curl_easy *data)
{
  /* c-ares has a method to "cancel" operations on a channel, but
   * as reported in #18216, this does not totally reset the channel
   * and ares may get stuck.
   * We need to destroy the channel and on demand create a new
   * one to avoid that. */
  Curl_async_ares_destroy(data);
}

void Curl_async_ares_destroy(struct Curl_easy *data)
{
  struct async_ares_ctx *ares = &data->state.async.ares;
  if(ares->channel) {
    ares_destroy(ares->channel);
    ares->channel = NULL;
  }
  async_ares_cleanup(data);
}

/*
 * Curl_async_pollset() is called when someone from the outside world
 * (using curl_multi_fdset()) wants to get our fd_set setup.
 */

CURLcode Curl_async_pollset(struct Curl_easy *data, struct easy_pollset *ps)
{
  struct async_ares_ctx *ares = &data->state.async.ares;
  if(ares->channel)
    return Curl_ares_pollset(data, ares->channel, ps);
  return CURLE_OK;
}

/*
 * Curl_async_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_async_is_resolved(struct Curl_easy *data,
                                struct Curl_dns_entry **dns)
{
  struct async_ares_ctx *ares = &data->state.async.ares;
  CURLcode result = CURLE_OK;

  DEBUGASSERT(dns);
  *dns = NULL;

  if(data->state.async.done) {
    *dns = data->state.async.dns;
    return ares->result;
  }

  if(Curl_ares_perform(ares->channel, 0) < 0) {
    result = CURLE_UNRECOVERABLE_POLL;
    goto out;
  }

#ifndef HAVE_CARES_GETADDRINFO
  /* Now that we have checked for any last minute results above, see if there
     are any responses still pending when the EXPIRE_HAPPY_EYEBALLS_DNS timer
     expires. */
  if(ares->num_pending
     /* This is only set to non-zero if the timer was started. */
     && (ares->happy_eyeballs_dns_time.tv_sec
         || ares->happy_eyeballs_dns_time.tv_usec)
     && (curlx_timediff(curlx_now(), ares->happy_eyeballs_dns_time)
         >= HAPPY_EYEBALLS_DNS_TIMEOUT)) {
    /* Remember that the EXPIRE_HAPPY_EYEBALLS_DNS timer is no longer
       running. */
    memset(&ares->happy_eyeballs_dns_time, 0,
           sizeof(ares->happy_eyeballs_dns_time));

    /* Cancel the raw c-ares request, which will fire query_completed_cb() with
       ARES_ECANCELLED synchronously for all pending responses. This will
       leave us with res->num_pending == 0, which is perfect for the next
       block. */
    ares_cancel(ares->channel);
    DEBUGASSERT(ares->num_pending == 0);
  }
#endif

  if(!ares->num_pending) {
    /* all c-ares operations done, what is the result to report? */
    Curl_resolv_unlink(data, &data->state.async.dns);
    data->state.async.done = TRUE;
    result = ares->result;
    if(ares->ares_status == ARES_SUCCESS && !result) {
      data->state.async.dns =
        Curl_dnscache_mk_entry(data, ares->temp_ai,
                               data->state.async.hostname, 0,
                               data->state.async.port, FALSE);
      ares->temp_ai = NULL; /* temp_ai now owned by entry */
#ifdef HTTPSRR_WORKS
      if(data->state.async.dns) {
        struct Curl_https_rrinfo *lhrr = Curl_httpsrr_dup_move(&ares->hinfo);
        if(!lhrr)
          result = CURLE_OUT_OF_MEMORY;
        else
          data->state.async.dns->hinfo = lhrr;
      }
#endif
      if(!result && data->state.async.dns)
        result = Curl_dnscache_add(data, data->state.async.dns);
    }
    /* if we have not found anything, report the proper
     * CURLE_COULDNT_RESOLVE_* code */
    if(!result && !data->state.async.dns) {
      const char *msg = NULL;
      if(ares->ares_status != ARES_SUCCESS)
        msg = ares_strerror(ares->ares_status);
      result = Curl_resolver_error(data, msg);
    }

    if(result)
      Curl_resolv_unlink(data, &data->state.async.dns);
    *dns = data->state.async.dns;
    CURL_TRC_DNS(data, "is_resolved() result=%d, dns=%sfound",
                 result, *dns ? "" : "not ");
    async_ares_cleanup(data);
  }

out:
  ares->result = result;
  return result;
}

/*
 * Curl_async_await()
 *
 * Waits for a resolve to finish. This function should be avoided since using
 * 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_async_await(struct Curl_easy *data,
                          struct Curl_dns_entry **entry)
{
  struct async_ares_ctx *ares = &data->state.async.ares;
  CURLcode result = CURLE_OK;
  timediff_t timeout;
  struct curltime now = curlx_now();

  DEBUGASSERT(entry);
  *entry = NULL; /* clear on entry */

  timeout = Curl_timeleft(data, &now, TRUE);
  if(timeout < 0) {
    /* already expired! */
    connclose(data->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. */
  while(!result) {
    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, &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;

    if(Curl_ares_perform(ares->channel, timeout_ms) < 0)
      return CURLE_UNRECOVERABLE_POLL;

    result = Curl_async_is_resolved(data, entry);
    if(result || data->state.async.done)
      break;

    if(Curl_pgrsUpdate(data))
      result = CURLE_ABORTED_BY_CALLBACK;
    else {
      struct curltime now2 = curlx_now();
      timediff_t timediff = curlx_timediff(now2, now); /* spent time */
      if(timediff <= 0)
        timeout -= 1; /* always deduct at least 1 */
      else if(timediff > timeout)
        timeout = -1;
      else
        timeout -= timediff;
      now = now2; /* for next loop */
    }
    if(timeout < 0)
      result = CURLE_OPERATION_TIMEDOUT;
  }

  /* Operation complete, if the lookup was successful we now have the entry
     in the cache. */
  data->state.async.done = TRUE;
  *entry = data->state.async.dns;

  if(result)
    ares_cancel(ares->channel);
  return result;
}

#ifndef HAVE_CARES_GETADDRINFO

/* Connects results to the list */
static void async_addr_concat(struct Curl_addrinfo **pbase,
                              struct Curl_addrinfo *ai)
{
  if(!ai)
    return;

  /* When adding `ai` to an existing address list, we prefer ipv6
   * to be in front. */
#ifdef USE_IPV6 /* CURLRES_IPV6 */
  if(*pbase && (*pbase)->ai_family == PF_INET6) {
    /* ipv6 already in front, append `ai` */
    struct Curl_addrinfo *tail = *pbase;
    while(tail->ai_next)
      tail = tail->ai_next;
    tail->ai_next = ai;
  }
  else
#endif /* CURLRES_IPV6 */
  {
    /* prepend to the (possibly) existing list. */
    struct Curl_addrinfo *tail = ai;
    while(tail->ai_next)
      tail = tail->ai_next;
    tail->ai_next = *pbase;
    *pbase = ai;
  }
}

/*
 * ares_query_completed_cb() is the callback that ares will call when
 * the host query initiated by ares_gethostbyname() from
 * Curl_async_getaddrinfo(), when using ares, is completed either
 * successfully or with failure.
 */
static void async_ares_hostbyname_cb(void *user_data,
                                     int status,
                                     int timeouts,
                                     struct hostent *hostent)
{
  struct Curl_easy *data = (struct Curl_easy *)user_data;
  struct async_ares_ctx *ares = &data->state.async.ares;

  (void)timeouts; /* ignored */

  if(ARES_EDESTRUCTION == status)
    return;

  if(ARES_SUCCESS == status) {
    ares->ares_status = status; /* one success overrules any error */
    async_addr_concat(&ares->temp_ai,
      Curl_he2ai(hostent, data->state.async.port));
  }
  else if(ares->ares_status != ARES_SUCCESS) {
    /* no success so far, remember last error */
    ares->ares_status = status;
  }

  ares->num_pending--;

  CURL_TRC_DNS(data, "ares: hostbyname done, status=%d, pending=%d, "
               "addr=%sfound",
               status, ares->num_pending, ares->temp_ai ? "" : "not ");
  /* If there are responses still pending, we presume they must be the
     complementary IPv4 or IPv6 lookups that we started in parallel in
     Curl_async_getaddrinfo() (for Happy Eyeballs). If we have got a
     "definitive" response from one of a set of parallel queries, we need to
     think about how long we are willing to wait for more responses. */
  if(ares->num_pending
     /* Only these c-ares status values count as "definitive" for these
        purposes. For example, ARES_ENODATA is what we expect when there is
        no IPv6 entry for a domain name, and that is not a reason to get more
        aggressive in our timeouts for the other response. Other errors are
        either a result of bad input (which should affect all parallel
        requests), local or network conditions, non-definitive server
        responses, or us cancelling the request. */
     && (status == ARES_SUCCESS || status == ARES_ENOTFOUND)) {
    /* Right now, there can only be up to two parallel queries, so do not
       bother handling any other cases. */
    DEBUGASSERT(ares->num_pending == 1);

    /* it is possible that one of these parallel queries could succeed
       quickly, but the other could always fail or timeout (when we are
       talking to a pool of DNS servers that can only successfully resolve
       IPv4 address, for example).

       it is also possible that the other request could always just take
       longer because it needs more time or only the second DNS server can
       fulfill it successfully. But, to align with the philosophy of Happy
       Eyeballs, we do not want to wait _too_ long or users will think
       requests are slow when IPv6 lookups do not actually work (but IPv4
       ones do).

       So, now that we have a usable answer (some IPv4 addresses, some IPv6
       addresses, or "no such domain"), we start a timeout for the remaining
       pending responses. Even though it is typical that this resolved
       request came back quickly, that needn't be the case. It might be that
       this completing request did not get a result from the first DNS
       server or even the first round of the whole DNS server pool. So it
       could already be quite some time after we issued the DNS queries in
       the first place. Without modifying c-ares, we cannot know exactly
       where in its retry cycle we are. We could guess based on how much
       time has gone by, but it does not really matter. Happy Eyeballs tells
       us that, given usable information in hand, we simply do not want to
       wait "too much longer" after we get a result.

       We simply wait an additional amount of time equal to the default
       c-ares query timeout. That is enough time for a typical parallel
       response to arrive without being "too long". Even on a network
       where one of the two types of queries is failing or timing out
       constantly, this will usually mean we wait a total of the default
       c-ares timeout (5 seconds) plus the round trip time for the successful
       request, which seems bearable. The downside is that c-ares might race
       with us to issue one more retry just before we give up, but it seems
       better to "waste" that request instead of trying to guess the perfect
       timeout to prevent it. After all, we do not even know where in the
       c-ares retry cycle each request is.
    */
    ares->happy_eyeballs_dns_time = curlx_now();
    Curl_expire(data, HAPPY_EYEBALLS_DNS_TIMEOUT,
                EXPIRE_HAPPY_EYEBALLS_DNS);
  }
}

#else
/* c-ares 1.16.0 or later */

/*
 * async_ares_node2addr() converts an address list provided by c-ares
 * to an internal libcurl compatible list.
 */
static struct Curl_addrinfo *
async_ares_node2addr(struct ares_addrinfo_node *node)
{
  /* traverse the ares_addrinfo_node list */
  struct ares_addrinfo_node *ai;
  struct Curl_addrinfo *cafirst = NULL;
  struct Curl_addrinfo *calast = NULL;
  int error = 0;

  for(ai = node; ai != NULL; ai = ai->ai_next) {
    size_t ss_size;
    struct Curl_addrinfo *ca;
    /* ignore elements with unsupported address family, */
    /* settle family-specific sockaddr structure size.  */
    if(ai->ai_family == AF_INET)
      ss_size = sizeof(struct sockaddr_in);
#ifdef USE_IPV6
    else if(ai->ai_family == AF_INET6)
      ss_size = sizeof(struct sockaddr_in6);
#endif
    else
      continue;

    /* ignore elements without required address info */
    if(!ai->ai_addr || !(ai->ai_addrlen > 0))
      continue;

    /* ignore elements with bogus address size */
    if((size_t)ai->ai_addrlen < ss_size)
      continue;

    ca = malloc(sizeof(struct Curl_addrinfo) + ss_size);
    if(!ca) {
      error = EAI_MEMORY;
      break;
    }

    /* copy each structure member individually, member ordering, */
    /* size, or padding might be different for each platform.    */

    ca->ai_flags     = ai->ai_flags;
    ca->ai_family    = ai->ai_family;
    ca->ai_socktype  = ai->ai_socktype;
    ca->ai_protocol  = ai->ai_protocol;
    ca->ai_addrlen   = (curl_socklen_t)ss_size;
    ca->ai_addr      = NULL;
    ca->ai_canonname = NULL;
    ca->ai_next      = NULL;

    ca->ai_addr = (void *)((char *)ca + sizeof(struct Curl_addrinfo));
    memcpy(ca->ai_addr, ai->ai_addr, ss_size);

    /* if the return list is empty, this becomes the first element */
    if(!cafirst)
      cafirst = ca;

    /* add this element last in the return list */
    if(calast)
      calast->ai_next = ca;
    calast = ca;
  }

  /* if we failed, destroy the Curl_addrinfo list */
  if(error) {
    Curl_freeaddrinfo(cafirst);
    cafirst = NULL;
  }

  return cafirst;
}

static void async_ares_addrinfo_cb(void *user_data, int status, int timeouts,
                                   struct ares_addrinfo *ares_ai)
{
  struct Curl_easy *data = (struct Curl_easy *)user_data;
  struct async_ares_ctx *ares = &data->state.async.ares;
  (void)timeouts;
  if(ares->ares_status != ARES_SUCCESS) /* do not overwrite success */
    ares->ares_status = status;
  if(status == ARES_SUCCESS) {
    ares->temp_ai = async_ares_node2addr(ares_ai->nodes);
    ares_freeaddrinfo(ares_ai);
  }
  ares->num_pending--;
  CURL_TRC_DNS(data, "ares: addrinfo done, query status=%d, "
               "overall status=%d, pending=%d, addr=%sfound",
               status, ares->ares_status, ares->num_pending,
               ares->temp_ai ? "" : "not ");
}

#endif

#ifdef USE_HTTPSRR
static void async_ares_rr_done(void *user_data, ares_status_t status,
                               size_t timeouts,
                               const ares_dns_record_t *dnsrec)
{
  struct Curl_easy *data = user_data;
  struct async_ares_ctx *ares = &data->state.async.ares;

  (void)timeouts;
  --ares->num_pending;
  CURL_TRC_DNS(data, "ares: httpsrr done, status=%d, pending=%d, "
               "dnsres=%sfound",
               status, ares->num_pending,
               (dnsrec &&
                ares_dns_record_rr_cnt(dnsrec, ARES_SECTION_ANSWER)) ?
                "" : "not ");
  if((ARES_SUCCESS != status) || !dnsrec)
    return;
  ares->result = Curl_httpsrr_from_ares(data, dnsrec, &ares->hinfo);
}
#endif /* USE_HTTPSRR */

/*
 * Curl_async_getaddrinfo() - when using ares
 *
 * Returns name information about the given hostname and port number. If
 * successful, the 'hostent' is returned and the fourth 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_async_getaddrinfo(struct Curl_easy *data,
                                             const char *hostname,
                                             int port,
                                             int ip_version,
                                             int *waitp)
{
  struct async_ares_ctx *ares = &data->state.async.ares;
#ifdef USE_HTTPSRR
  char *rrname = NULL;
#endif
  *waitp = 0; /* default to synchronous response */

  if(async_ares_init_lazy(data))
    return NULL;

  data->state.async.done = FALSE;   /* not done */
  data->state.async.dns = NULL;     /* clear */
  data->state.async.port = port;
  data->state.async.ip_version = ip_version;
  data->state.async.hostname = strdup(hostname);
  if(!data->state.async.hostname)
    return NULL;
#ifdef USE_HTTPSRR
  if(port != 443) {
    rrname = curl_maprintf("_%d_.https.%s", port, hostname);
    if(!rrname) {
      free(data->state.async.hostname);
      return NULL;
    }
  }
#endif

  /* initial status - failed */
  ares->ares_status = ARES_ENOTFOUND;
  ares->result = CURLE_OK;

#if !defined(CURL_DISABLE_VERBOSE_STRINGS) && \
  ARES_VERSION >= 0x011800  /* >= v1.24.0 */
  if(CURL_TRC_DNS_is_verbose(data)) {
    char *csv = ares_get_servers_csv(ares->channel);
    CURL_TRC_DNS(data, "asyn-ares: servers=%s", csv);
    ares_free_string(csv);
  }
#endif

#ifdef HAVE_CARES_GETADDRINFO
  {
    struct ares_addrinfo_hints hints;
    char service[12];
    int pf = PF_INET;
    memset(&hints, 0, sizeof(hints));
#ifdef CURLRES_IPV6
    if((ip_version != CURL_IPRESOLVE_V4) &&
       Curl_ipv6works(data)) {
      /* The stack seems to be IPv6-enabled */
      if(ip_version == CURL_IPRESOLVE_V6)
        pf = PF_INET6;
      else
        pf = PF_UNSPEC;
    }
#endif /* CURLRES_IPV6 */
    CURL_TRC_DNS(data, "asyn-ares: fire off getaddrinfo for %s",
                 (pf == PF_UNSPEC) ? "A+AAAA" :
                 ((pf == PF_INET) ? "A" : "AAAA"));
    hints.ai_family = pf;
    hints.ai_socktype =
      (Curl_conn_get_transport(data, data->conn) == TRNSPRT_TCP) ?
      SOCK_STREAM : SOCK_DGRAM;
    /* Since the service is a numerical one, set the hint flags
     * accordingly to save a call to getservbyname in inside C-Ares
     */
    hints.ai_flags = ARES_AI_NUMERICSERV;
    curl_msnprintf(service, sizeof(service), "%d", port);
    ares->num_pending = 1;
    ares_getaddrinfo(ares->channel, data->state.async.hostname,
                     service, &hints, async_ares_addrinfo_cb, data);
  }
#else

#ifdef HAVE_CARES_IPV6
  if((ip_version != CURL_IPRESOLVE_V4) && Curl_ipv6works(data)) {
    /* The stack seems to be IPv6-enabled */
    /* areschannel is already setup in the Curl_open() function */
    CURL_TRC_DNS(data, "asyn-ares: fire off query for A");
    ares_gethostbyname(ares->channel, data->state.async.hostname, PF_INET,
                       async_ares_hostbyname_cb, data);
    CURL_TRC_DNS(data, "asyn-ares: fire off query for AAAA");
    ares->num_pending = 2;
    ares_gethostbyname(ares->channel, data->state.async.hostname, PF_INET6,
                       async_ares_hostbyname_cb, data);
  }
  else
#endif
  {
    /* areschannel is already setup in the Curl_open() function */
    CURL_TRC_DNS(data, "asyn-ares: fire off query for A");
    ares->num_pending = 1;
    ares_gethostbyname(ares->channel, data->state.async.hostname, PF_INET,
                       async_ares_hostbyname_cb, data);
  }
#endif
#ifdef USE_HTTPSRR
  {
    CURL_TRC_DNS(data, "asyn-ares: fire off query for HTTPSRR: %s",
                 rrname ? rrname : data->state.async.hostname);
    memset(&ares->hinfo, 0, sizeof(ares->hinfo));
    ares->hinfo.port = -1;
    ares->hinfo.rrname = rrname;
    ares->num_pending++; /* one more */
    ares_query_dnsrec(ares->channel,
                      rrname ? rrname : data->state.async.hostname,
                      ARES_CLASS_IN, ARES_REC_TYPE_HTTPS,
                      async_ares_rr_done, data, NULL);
  }
#endif
  *waitp = 1; /* expect asynchronous response */

  return NULL; /* no struct yet */
}

/* Set what DNS server are is to use. This is called in 2 situations:
 * 1. when the application does 'CURLOPT_DNS_SERVERS' and passing NULL
 *    means any previous set value should be unset. Which means
 *    we need to destroy and create the are channel anew, if there is one.
 * 2. When we lazy init the ares channel and NULL means that there
 *    are no preferences and we do not reset any existing channel. */
static CURLcode async_ares_set_dns_servers(struct Curl_easy *data,
                                           bool reset_on_null)
{
  struct async_ares_ctx *ares = &data->state.async.ares;
  CURLcode result = CURLE_NOT_BUILT_IN;
  const char *servers = data->set.str[STRING_DNS_SERVERS];
  int ares_result = ARES_SUCCESS;

#if defined(CURLDEBUG) && defined(HAVE_CARES_SERVERS_CSV)
  if(getenv("CURL_DNS_SERVER"))
    servers = getenv("CURL_DNS_SERVER");
#endif

  if(!servers) {
    if(reset_on_null) {
      Curl_async_destroy(data);
    }
    return CURLE_OK;
  }

#ifdef HAVE_CARES_SERVERS_CSV
  /* if channel is not there, this is just a parameter check */
  if(ares->channel)
#ifdef HAVE_CARES_PORTS_CSV
    ares_result = ares_set_servers_ports_csv(ares->channel, servers);
#else
    ares_result = ares_set_servers_csv(ares->channel, 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:
    DEBUGF(infof(data, "bad servers set"));
    result = CURLE_BAD_FUNCTION_ARGUMENT;
    break;
  }
#else /* too old c-ares version! */
  (void)data;
  (void)(ares_result);
#endif
  return result;
}

CURLcode Curl_async_ares_set_dns_servers(struct Curl_easy *data)
{
  return async_ares_set_dns_servers(data, TRUE);
}

CURLcode Curl_async_ares_set_dns_interface(struct Curl_easy *data)
{
#ifdef HAVE_CARES_LOCAL_DEV
  struct async_ares_ctx *ares = &data->state.async.ares;
  const char *interf = data->set.str[STRING_DNS_INTERFACE];

  if(!interf)
    interf = "";

  /* if channel is not there, this is just a parameter check */
  if(ares->channel)
    ares_set_local_dev(ares->channel, interf);

  return CURLE_OK;
#else /* c-ares version too old! */
  (void)data;
  (void)interf;
  return CURLE_NOT_BUILT_IN;
#endif
}

CURLcode Curl_async_ares_set_dns_local_ip4(struct Curl_easy *data)
{
#ifdef HAVE_CARES_SET_LOCAL
  struct async_ares_ctx *ares = &data->state.async.ares;
  struct in_addr a4;
  const char *local_ip4 = data->set.str[STRING_DNS_LOCAL_IP4];

  if((!local_ip4) || (local_ip4[0] == 0)) {
    a4.s_addr = 0; /* disabled: do not bind to a specific address */
  }
  else {
    if(curlx_inet_pton(AF_INET, local_ip4, &a4) != 1) {
      DEBUGF(infof(data, "bad DNS IPv4 address"));
      return CURLE_BAD_FUNCTION_ARGUMENT;
    }
  }

  /* if channel is not there yet, this is just a parameter check */
  if(ares->channel)
    ares_set_local_ip4(ares->channel, ntohl(a4.s_addr));

  return CURLE_OK;
#else /* c-ares version too old! */
  (void)data;
  (void)local_ip4;
  return CURLE_NOT_BUILT_IN;
#endif
}

CURLcode Curl_async_ares_set_dns_local_ip6(struct Curl_easy *data)
{
#if defined(HAVE_CARES_SET_LOCAL) && defined(USE_IPV6)
  struct async_ares_ctx *ares = &data->state.async.ares;
  unsigned char a6[INET6_ADDRSTRLEN];
  const char *local_ip6 = data->set.str[STRING_DNS_LOCAL_IP6];

  if((!local_ip6) || (local_ip6[0] == 0)) {
    /* disabled: do not bind to a specific address */
    memset(a6, 0, sizeof(a6));
  }
  else {
    if(curlx_inet_pton(AF_INET6, local_ip6, a6) != 1) {
      DEBUGF(infof(data, "bad DNS IPv6 address"));
      return CURLE_BAD_FUNCTION_ARGUMENT;
    }
  }

  /* if channel is not there, this is just a parameter check */
  if(ares->channel)
    ares_set_local_ip6(ares->channel, a6);

  return CURLE_OK;
#else /* c-ares version too old! */
  (void)data;
  return CURLE_NOT_BUILT_IN;
#endif
}

#endif /* CURLRES_ARES */
