luna - curl/lib/hostip.c

   1/***************************************************************************
   2 *                                  _   _ ____  _
   3 *  Project                     ___| | | |  _ \| |
   4 *                             / __| | | | |_) | |
   5 *                            | (__| |_| |  _ <| |___
   6 *                             \___|\___/|_| \_\_____|
   7 *
   8 * Copyright (C) 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.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 * SPDX-License-Identifier: curl
  22 *
  23 ***************************************************************************/
  24#include "curl_setup.h"
  25
  26#ifdef HAVE_NETINET_IN_H
  27#include <netinet/in.h>
  28#endif
  29#ifdef HAVE_NETINET_IN6_H
  30#include <netinet/in6.h>
  31#endif
  32#ifdef HAVE_NETDB_H
  33#include <netdb.h>
  34#endif
  35#ifdef HAVE_ARPA_INET_H
  36#include <arpa/inet.h>
  37#endif
  38#ifdef __VMS
  39#include <in.h>
  40#include <inet.h>
  41#endif
  42
  43#include <setjmp.h>  /* for sigjmp_buf, sigsetjmp() */
  44#include <signal.h>
  45
  46#include "urldata.h"
  47#include "curl_addrinfo.h"
  48#include "curl_trc.h"
  49#include "dnscache.h"
  50#include "hostip.h"
  51#include "httpsrr.h"
  52#include "url.h"
  53#include "multiif.h"
  54#include "progress.h"
  55#include "doh.h"
  56#include "select.h"
  57#include "strcase.h"
  58#include "easy_lock.h"
  59#include "curlx/inet_ntop.h"
  60#include "curlx/inet_pton.h"
  61#include "curlx/strcopy.h"
  62#include "curlx/strparse.h"
  63
  64#if defined(CURLRES_SYNCH) &&                   \
  65  defined(HAVE_ALARM) &&                        \
  66  defined(SIGALRM) &&                           \
  67  defined(HAVE_SIGSETJMP) &&                    \
  68  defined(GLOBAL_INIT_IS_THREADSAFE)
  69/* alarm-based timeouts can only be used with all the dependencies satisfied */
  70#define USE_ALARM_TIMEOUT
  71#endif
  72
  73#define RESOLV_FAIL(for_proxy) \
  74  ((for_proxy) ? CURLE_COULDNT_RESOLVE_PROXY : CURLE_COULDNT_RESOLVE_HOST)
  75
  76#define IS_RESOLV_FAIL(result) \
  77  (((result) == CURLE_COULDNT_RESOLVE_HOST) || \
  78   ((result) == CURLE_COULDNT_RESOLVE_PROXY))
  79/*
  80 * ipv6works() returns TRUE if IPv6 seems to work.
  81 */
  82#ifdef USE_IPV6
  83static bool ipv6works(struct Curl_easy *data);
  84#else
  85#define ipv6works(x) FALSE
  86#endif
  87
  88/*
  89 * hostip.c explained
  90 * ==================
  91 *
  92 * The main COMPILE-TIME DEFINES to keep in mind when reading the host*.c
  93 * source file are these:
  94 *
  95 * CURLRES_IPV6 - this host has getaddrinfo() and family, and thus we use
  96 * that. The host may not be able to resolve IPv6, but we do not really have to
  97 * take that into account. Hosts that are not IPv6-enabled have CURLRES_IPV4
  98 * defined.
  99 *
 100 * USE_RESOLV_ARES - is defined if libcurl is built to use c-ares for
 101 * asynchronous name resolves. This can be Windows or *nix.
 102 *
 103 * USE_RESOLV_THREADED - is defined if libcurl is built to run under (native)
 104 * Windows, and then the name resolve will be done in a new thread, and the
 105 * supported API will be the same as for ares-builds.
 106 *
 107 * If any of the two previous are defined, CURLRES_ASYNCH is defined too. If
 108 * libcurl is not built to use an asynchronous resolver, CURLRES_SYNCH is
 109 * defined.
 110 *
 111 * The host*.c sources files are split up like this:
 112 *
 113 * hostip.c   - method-independent resolver functions and utility functions
 114 * hostip4.c  - IPv4 specific functions
 115 * hostip6.c  - IPv6 specific functions
 116 * asyn.h     - common functions for all async resolvers
 117 * The two asynchronous name resolver backends are implemented in:
 118 * asyn-ares.c - async resolver using c-ares
 119 * asyn-thread.c - async resolver using POSIX threads
 120 *
 121 * The hostip.h is the united header file for all this. It defines the
 122 * CURLRES_* defines based on the config*.h and curl_setup.h defines.
 123 */
 124
 125uint8_t Curl_resolv_dns_queries(struct Curl_easy *data, uint8_t ip_version)
 126{
 127  (void)data;
 128  switch(ip_version) {
 129  case CURL_IPRESOLVE_V6:
 130    return CURL_DNSQ_AAAA;
 131  case CURL_IPRESOLVE_V4:
 132    return CURL_DNSQ_A;
 133  default:
 134    if(ipv6works(data))
 135      return (CURL_DNSQ_A | CURL_DNSQ_AAAA);
 136    else
 137      return CURL_DNSQ_A;
 138  }
 139}
 140
 141#ifdef CURLVERBOSE
 142const char *Curl_resolv_query_str(uint8_t dns_queries)
 143{
 144  switch(dns_queries) {
 145  case (CURL_DNSQ_A | CURL_DNSQ_AAAA | CURL_DNSQ_HTTPS):
 146    return "A+AAAA+HTTPS";
 147  case (CURL_DNSQ_A | CURL_DNSQ_AAAA):
 148    return "A+AAAA";
 149  case (CURL_DNSQ_AAAA | CURL_DNSQ_HTTPS):
 150    return "AAAA+HTTPS";
 151  case (CURL_DNSQ_AAAA):
 152    return "AAAA";
 153  case (CURL_DNSQ_A | CURL_DNSQ_HTTPS):
 154    return "A+HTTPS";
 155  case (CURL_DNSQ_A):
 156    return "A";
 157  case (CURL_DNSQ_HTTPS):
 158    return "HTTPS";
 159  case 0:
 160    return "-";
 161  default:
 162    DEBUGASSERT(0);
 163    return "???";
 164  }
 165}
 166#endif
 167
 168/*
 169 * Curl_printable_address() stores a printable version of the 1st address
 170 * given in the 'ai' argument. The result will be stored in the buf that is
 171 * bufsize bytes big.
 172 *
 173 * If the conversion fails, the target buffer is empty.
 174 */
 175void Curl_printable_address(const struct Curl_addrinfo *ai, char *buf,
 176                            size_t bufsize)
 177{
 178  DEBUGASSERT(bufsize);
 179  buf[0] = 0;
 180
 181  switch(ai->ai_family) {
 182  case AF_INET: {
 183    const struct sockaddr_in *sa4 = (const void *)ai->ai_addr;
 184    const struct in_addr *ipaddr4 = &sa4->sin_addr;
 185    (void)curlx_inet_ntop(ai->ai_family, (const void *)ipaddr4, buf, bufsize);
 186    break;
 187  }
 188#ifdef USE_IPV6
 189  case AF_INET6: {
 190    const struct sockaddr_in6 *sa6 = (const void *)ai->ai_addr;
 191    const struct in6_addr *ipaddr6 = &sa6->sin6_addr;
 192    (void)curlx_inet_ntop(ai->ai_family, (const void *)ipaddr6, buf, bufsize);
 193    break;
 194  }
 195#endif
 196  default:
 197    break;
 198  }
 199}
 200
 201#ifdef USE_ALARM_TIMEOUT
 202/* Beware this is a global and unique instance. This is used to store the
 203   return address that we can jump back to from inside a signal handler. This
 204   is not thread-safe stuff. */
 205static sigjmp_buf curl_jmpenv;
 206static curl_simple_lock curl_jmpenv_lock = CURL_SIMPLE_LOCK_INIT;
 207#endif
 208
 209#ifdef USE_IPV6
 210/* return a static IPv6 ::1 for the name */
 211static struct Curl_addrinfo *get_localhost6(uint16_t port, const char *name)
 212{
 213  struct Curl_addrinfo *ca;
 214  const size_t ss_size = sizeof(struct sockaddr_in6);
 215  const size_t hostlen = strlen(name);
 216  struct sockaddr_in6 sa6;
 217  unsigned char ipv6[16];
 218  unsigned short port16 = (unsigned short)(port & 0xffff);
 219  ca = curlx_calloc(1, sizeof(struct Curl_addrinfo) + ss_size + hostlen + 1);
 220  if(!ca)
 221    return NULL;
 222
 223  memset(&sa6, 0, sizeof(sa6));
 224  sa6.sin6_family = AF_INET6;
 225  sa6.sin6_port = htons(port16);
 226
 227  (void)curlx_inet_pton(AF_INET6, "::1", ipv6);
 228  memcpy(&sa6.sin6_addr, ipv6, sizeof(ipv6));
 229
 230  ca->ai_flags     = 0;
 231  ca->ai_family    = AF_INET6;
 232  ca->ai_socktype  = SOCK_STREAM;
 233  ca->ai_protocol  = IPPROTO_TCP;
 234  ca->ai_addrlen   = (curl_socklen_t)ss_size;
 235  ca->ai_next      = NULL;
 236  ca->ai_addr = (void *)((char *)ca + sizeof(struct Curl_addrinfo));
 237  memcpy(ca->ai_addr, &sa6, ss_size);
 238  ca->ai_canonname = (char *)ca->ai_addr + ss_size;
 239  curlx_strcopy(ca->ai_canonname, hostlen + 1, name, hostlen);
 240  return ca;
 241}
 242#else
 243#define get_localhost6(x, y) NULL
 244#endif
 245
 246/* return a static IPv4 127.0.0.1 for the given name */
 247static struct Curl_addrinfo *get_localhost(uint16_t port, const char *name)
 248{
 249  struct Curl_addrinfo *ca;
 250  struct Curl_addrinfo *ca6;
 251  const size_t ss_size = sizeof(struct sockaddr_in);
 252  const size_t hostlen = strlen(name);
 253  struct sockaddr_in sa;
 254  unsigned int ipv4;
 255  unsigned short port16 = (unsigned short)(port & 0xffff);
 256
 257  /* memset to clear the sa.sin_zero field */
 258  memset(&sa, 0, sizeof(sa));
 259  sa.sin_family = AF_INET;
 260  sa.sin_port = htons(port16);
 261  if(curlx_inet_pton(AF_INET, "127.0.0.1", (char *)&ipv4) < 1)
 262    return NULL;
 263  memcpy(&sa.sin_addr, &ipv4, sizeof(ipv4));
 264
 265  ca = curlx_calloc(1, sizeof(struct Curl_addrinfo) + ss_size + hostlen + 1);
 266  if(!ca)
 267    return NULL;
 268  ca->ai_flags     = 0;
 269  ca->ai_family    = AF_INET;
 270  ca->ai_socktype  = SOCK_STREAM;
 271  ca->ai_protocol  = IPPROTO_TCP;
 272  ca->ai_addrlen   = (curl_socklen_t)ss_size;
 273  ca->ai_addr = (void *)((char *)ca + sizeof(struct Curl_addrinfo));
 274  memcpy(ca->ai_addr, &sa, ss_size);
 275  ca->ai_canonname = (char *)ca->ai_addr + ss_size;
 276  curlx_strcopy(ca->ai_canonname, hostlen + 1, name, hostlen);
 277
 278  ca6 = get_localhost6(port, name);
 279  if(!ca6)
 280    return ca;
 281  ca6->ai_next = ca;
 282  return ca6;
 283}
 284
 285#ifdef USE_IPV6
 286/* the nature of most systems is that IPv6 status does not come and go during a
 287   program's lifetime so we only probe the first time and then we have the
 288   info kept for fast reuse */
 289CURLcode Curl_probeipv6(struct Curl_multi *multi)
 290{
 291  /* probe to see if we have a working IPv6 stack */
 292  curl_socket_t s = CURL_SOCKET(PF_INET6, SOCK_DGRAM, 0);
 293  multi->ipv6_works = FALSE;
 294  if(s == CURL_SOCKET_BAD) {
 295    if(SOCKERRNO == SOCKENOMEM)
 296      return CURLE_OUT_OF_MEMORY;
 297  }
 298  else {
 299    multi->ipv6_works = TRUE;
 300    sclose(s);
 301  }
 302  return CURLE_OK;
 303}
 304
 305/*
 306 * ipv6works() returns TRUE if IPv6 seems to work.
 307 */
 308static bool ipv6works(struct Curl_easy *data)
 309{
 310  DEBUGASSERT(data);
 311  DEBUGASSERT(data->multi);
 312  return data ? data->multi->ipv6_works : FALSE;
 313}
 314#endif /* USE_IPV6 */
 315
 316/*
 317 * Curl_host_is_ipnum() returns TRUE if the given string is a numerical IPv4
 318 * (or IPv6 if supported) address.
 319 */
 320bool Curl_host_is_ipnum(const char *hostname)
 321{
 322  struct in_addr in;
 323#ifdef USE_IPV6
 324  struct in6_addr in6;
 325#endif
 326  if(curlx_inet_pton(AF_INET, hostname, &in) > 0
 327#ifdef USE_IPV6
 328     || curlx_inet_pton(AF_INET6, hostname, &in6) > 0
 329#endif
 330    )
 331    return TRUE;
 332  return FALSE;
 333}
 334
 335/* return TRUE if 'part' is a case insensitive tail of 'full' */
 336static bool tailmatch(const char *full, size_t flen,
 337                      const char *part, size_t plen)
 338{
 339  if(plen > flen)
 340    return FALSE;
 341  return curl_strnequal(part, &full[flen - plen], plen);
 342}
 343
 344static CURLcode hostip_resolv_failed(struct Curl_easy *data,
 345                                     const char *hostname,
 346                                     bool for_proxy)
 347{
 348  failf(data, "Could not resolve %s: %s",
 349        for_proxy ? "proxy" : "host", hostname);
 350  return RESOLV_FAIL(for_proxy);
 351}
 352
 353static bool can_resolve_dns_queries(struct Curl_easy *data,
 354                                    uint8_t dns_queries)
 355{
 356  (void)data;
 357  if((CURL_DNSQ_IP(dns_queries) == CURL_DNSQ_AAAA) && !ipv6works(data))
 358    return FALSE;
 359  return TRUE;
 360}
 361
 362CURLcode Curl_resolv_announce_start(struct Curl_easy *data,
 363                                    void *resolver)
 364{
 365  if(data->set.resolver_start) {
 366    int rc;
 367
 368    CURL_TRC_DNS(data, "announcing resolve to application");
 369    Curl_set_in_callback(data, TRUE);
 370    rc = data->set.resolver_start(resolver, NULL,
 371                                  data->set.resolver_start_client);
 372    Curl_set_in_callback(data, FALSE);
 373    if(rc) {
 374      CURL_TRC_DNS(data, "application aborted resolve");
 375      return CURLE_ABORTED_BY_CALLBACK;
 376    }
 377  }
 378  return CURLE_OK;
 379}
 380
 381#ifdef USE_CURL_ASYNC
 382
 383static struct Curl_resolv_async *hostip_async_new(struct Curl_easy *data,
 384                                                  uint8_t dns_queries,
 385                                                  const char *hostname,
 386                                                  uint16_t port,
 387                                                  uint8_t transport,
 388                                                  bool for_proxy,
 389                                                  timediff_t timeout_ms)
 390{
 391  struct Curl_resolv_async *async;
 392  size_t hostlen = strlen(hostname);
 393
 394  if(!data->multi) {
 395    DEBUGASSERT(0);
 396    return NULL;
 397  }
 398
 399  /* struct size already includes the NUL for hostname */
 400  async = curlx_calloc(1, sizeof(*async) + hostlen);
 401  if(!async)
 402    return NULL;
 403
 404  /* Give every async resolve operation a "unique" id. This may
 405   * wrap around after a long time, making collisions highly unlikely.
 406   * As we keep the async structs at the easy handle, chances of
 407   * easy `mid plus resolv->id` colliding should be astronomical.
 408   * `resolv_id == 0` is never used. */
 409  if(data->multi->last_resolv_id == UINT32_MAX)
 410    data->multi->last_resolv_id = 1; /* wrap around */
 411  else
 412    data->multi->last_resolv_id++;
 413  async->id = data->multi->last_resolv_id;
 414  async->dns_queries = dns_queries;
 415  async->port = port;
 416  async->transport = transport;
 417  async->for_proxy = for_proxy;
 418  async->start = *Curl_pgrs_now(data);
 419  async->timeout_ms = timeout_ms;
 420  if(hostlen) {
 421    memcpy(async->hostname, hostname, hostlen);
 422    async->is_ipaddr = Curl_is_ipaddr(async->hostname);
 423    if(async->is_ipaddr)
 424      async->is_ipv4addr = Curl_is_ipv4addr(async->hostname);
 425  }
 426
 427  return async;
 428}
 429
 430static CURLcode hostip_resolv_take_result(struct Curl_easy *data,
 431                                          struct Curl_resolv_async *async,
 432                                          struct Curl_dns_entry **pdns)
 433{
 434  CURLcode result;
 435
 436  /* If async resolving is ongoing, this must be set */
 437  if(!async)
 438    return CURLE_FAILED_INIT;
 439
 440#ifndef CURL_DISABLE_DOH
 441  if(async->doh)
 442    result = Curl_doh_take_result(data, async, pdns);
 443  else
 444#endif
 445  result = Curl_async_take_result(data, async, pdns);
 446
 447  if(result == CURLE_AGAIN) {
 448    CURL_TRC_DNS(data, "resolve incomplete, queries=%s, responses=%s, "
 449                 "ongoing=%d for %s:%d",
 450                 Curl_resolv_query_str(async->dns_queries),
 451                 Curl_resolv_query_str(async->dns_responses),
 452                 async->queries_ongoing, async->hostname, async->port);
 453    result = CURLE_OK;
 454  }
 455  else if(result) {
 456    result = Curl_async_failed(data, async, NULL);
 457  }
 458  else {
 459    CURL_TRC_DNS(data, "resolve complete for %s:%u",
 460                 async->hostname, async->port);
 461    DEBUGASSERT(*pdns);
 462  }
 463
 464  return result;
 465}
 466
 467timediff_t Curl_resolv_elapsed_ms(struct Curl_easy *data,
 468                                  uint32_t resolv_id)
 469{
 470  struct Curl_resolv_async *async = Curl_async_get(data, resolv_id);
 471  if(!async)
 472    return CURL_TIMEOUT_RESOLVE_MS;
 473  return curlx_ptimediff_ms(Curl_pgrs_now(data), &async->start);
 474}
 475
 476bool Curl_resolv_has_answers(struct Curl_easy *data,
 477                             uint32_t resolv_id, uint8_t dns_queries)
 478{
 479  struct Curl_resolv_async *async = Curl_async_get(data, resolv_id);
 480  uint8_t check_queries;
 481  /* a no longer existing/running resolve has all answers. */
 482  if(!async || async->done)
 483    return TRUE;
 484  /* Relevant are only queries undertaken. Others are considered answered. */
 485  check_queries = (dns_queries & async->dns_queries);
 486  if((check_queries & async->dns_responses) != check_queries) {
 487    return FALSE;
 488  }
 489  return TRUE;
 490}
 491
 492const struct Curl_addrinfo *Curl_resolv_get_ai(struct Curl_easy *data,
 493                                               uint32_t resolv_id,
 494                                               int ai_family,
 495                                               unsigned int index)
 496{
 497  struct Curl_resolv_async *async = Curl_async_get(data, resolv_id);
 498  (void)index;
 499  if(!async)
 500    return NULL;
 501  if((ai_family == AF_INET) && !(async->dns_queries & CURL_DNSQ_A))
 502    return NULL;
 503#ifdef USE_IPV6
 504  if((ai_family == AF_INET6) && !(async->dns_queries & CURL_DNSQ_AAAA))
 505    return NULL;
 506#endif
 507  return Curl_async_get_ai(data, async, ai_family, index);
 508}
 509
 510#ifdef USE_HTTPSRR
 511const struct Curl_https_rrinfo *
 512Curl_resolv_get_https(struct Curl_easy *data, uint32_t resolv_id)
 513{
 514  struct Curl_resolv_async *async = Curl_async_get(data, resolv_id);
 515  if(!async)
 516    return NULL;
 517  return Curl_async_get_https(data, async);
 518}
 519
 520bool Curl_resolv_knows_https(struct Curl_easy *data, uint32_t resolv_id)
 521{
 522  struct Curl_resolv_async *async = Curl_async_get(data, resolv_id);
 523  if(!async)
 524    return TRUE;
 525  return Curl_async_knows_https(data, async);
 526}
 527#endif /* USE_HTTPSRR */
 528
 529#endif /* USE_CURL_ASYNC */
 530
 531static CURLcode hostip_resolv_start(struct Curl_easy *data,
 532                                    uint8_t dns_queries,
 533                                    const char *hostname,
 534                                    uint16_t port,
 535                                    uint8_t transport,
 536                                    bool for_proxy,
 537                                    timediff_t timeout_ms,
 538                                    bool allowDOH,
 539                                    uint32_t *presolv_id,
 540                                    struct Curl_dns_entry **pdns)
 541{
 542#ifdef USE_CURL_ASYNC
 543  struct Curl_resolv_async *async = NULL;
 544#endif
 545  struct Curl_addrinfo *addr = NULL;
 546  size_t hostname_len;
 547  CURLcode result = CURLE_OK;
 548
 549  (void)timeout_ms; /* not in all ifdefs */
 550  *presolv_id = 0;
 551  *pdns = NULL;
 552
 553  /* Check for "known" things to resolve ourselves. */
 554#ifndef USE_RESOLVE_ON_IPS
 555  if(Curl_is_ipaddr(hostname)) {
 556    /* test655 verifies that the announce is done, even though there
 557     * is no real resolving. So, keep doing this. */
 558    result = Curl_resolv_announce_start(data, NULL);
 559    if(result)
 560      goto out;
 561    /* shortcut literal IP addresses, if we are not told to resolve them. */
 562    result = Curl_str2addr(hostname, port, &addr);
 563    goto out;
 564  }
 565#endif
 566
 567  hostname_len = strlen(hostname);
 568  if(curl_strequal(hostname, "localhost") ||
 569     curl_strequal(hostname, "localhost.") ||
 570     tailmatch(hostname, hostname_len, STRCONST(".localhost")) ||
 571     tailmatch(hostname, hostname_len, STRCONST(".localhost."))) {
 572    result = Curl_resolv_announce_start(data, NULL);
 573    if(result)
 574      goto out;
 575    addr = get_localhost(port, hostname);
 576    if(!addr)
 577      result = CURLE_OUT_OF_MEMORY;
 578    goto out;
 579  }
 580
 581#ifndef CURL_DISABLE_DOH
 582  if(!Curl_is_ipaddr(hostname) && allowDOH && data->set.doh) {
 583    result = Curl_resolv_announce_start(data, NULL);
 584    if(result)
 585      goto out;
 586    if(!async) {
 587      async = hostip_async_new(data, dns_queries, hostname, port,
 588                               transport, for_proxy, timeout_ms);
 589      if(!async) {
 590        result = CURLE_OUT_OF_MEMORY;
 591        goto out;
 592      }
 593    }
 594    result = Curl_doh(data, async);
 595    goto out;
 596  }
 597#else
 598  (void)allowDOH;
 599#endif
 600
 601  /* Can we provide the requested IP specifics in resolving? */
 602  if(!can_resolve_dns_queries(data, dns_queries)) {
 603    result = RESOLV_FAIL(for_proxy);
 604    goto out;
 605  }
 606
 607#ifdef CURLRES_ASYNCH
 608  (void)addr;
 609  if(!async) {
 610    async = hostip_async_new(data, dns_queries, hostname, port,
 611                             transport, for_proxy, timeout_ms);
 612    if(!async) {
 613      result = CURLE_OUT_OF_MEMORY;
 614      goto out;
 615    }
 616  }
 617  result = Curl_async_getaddrinfo(data, async);
 618  if(result == CURLE_AGAIN) {
 619    /* the answer might be there already. Check. */
 620    CURLcode r2 = hostip_resolv_take_result(data, async, pdns);
 621    if(r2)
 622      result = r2;
 623    else if(*pdns)
 624      result = CURLE_OK;
 625  }
 626#else
 627  result = Curl_resolv_announce_start(data, NULL);
 628  if(result)
 629    goto out;
 630  addr = Curl_sync_getaddrinfo(data, dns_queries, hostname, port, transport);
 631  if(!addr)
 632    result = RESOLV_FAIL(for_proxy);
 633#endif
 634
 635out:
 636  if(!result) {
 637    if(addr) {
 638      /* we got a response, create a dns entry, add to cache, return */
 639      DEBUGASSERT(!*pdns);
 640      *pdns = Curl_dnscache_mk_entry(data, dns_queries, &addr, hostname, port);
 641      if(!*pdns)
 642        result = CURLE_OUT_OF_MEMORY;
 643    }
 644    else if(!*pdns)
 645      result = CURLE_AGAIN;
 646  }
 647  else if(*pdns)
 648    Curl_dns_entry_unlink(data, pdns);
 649  else if(addr)
 650    Curl_freeaddrinfo(addr);
 651
 652#ifdef USE_CURL_ASYNC
 653  if(async) {
 654    if(result == CURLE_AGAIN) { /* still need it, link, return id. */
 655      *presolv_id = async->id;
 656      async->next = data->state.async;
 657      data->state.async = async;
 658    }
 659    else {
 660      Curl_async_destroy(data, async);
 661    }
 662  }
 663#endif
 664  return result;
 665}
 666
 667static CURLcode hostip_resolv(struct Curl_easy *data,
 668                              uint8_t dns_queries,
 669                              const char *hostname,
 670                              uint16_t port,
 671                              uint8_t transport,
 672                              bool for_proxy,
 673                              timediff_t timeout_ms,
 674                              bool allowDOH,
 675                              uint32_t *presolv_id,
 676                              struct Curl_dns_entry **pdns)
 677{
 678  size_t hostname_len;
 679  CURLcode result = RESOLV_FAIL(for_proxy);
 680  bool cache_dns = FALSE;
 681
 682  (void)timeout_ms; /* not used in all ifdefs */
 683  *presolv_id = 0;
 684  *pdns = NULL;
 685
 686#ifdef CURL_DISABLE_DOH
 687  (void)allowDOH;
 688#endif
 689
 690  /* We should intentionally error and not resolve .onion TLDs */
 691  hostname_len = strlen(hostname);
 692  DEBUGASSERT(hostname_len);
 693  if(hostname_len >= 7 &&
 694     (curl_strequal(&hostname[hostname_len - 6], ".onion") ||
 695      curl_strequal(&hostname[hostname_len - 7], ".onion."))) {
 696    failf(data, "Not resolving .onion address (RFC 7686)");
 697    goto out;
 698  }
 699
 700#ifdef DEBUGBUILD
 701  CURL_TRC_DNS(data, "hostip_resolv(%s:%u, queries=%s)",
 702               hostname, port, Curl_resolv_query_str(dns_queries));
 703  if((CURL_DNSQ_IP(dns_queries) == CURL_DNSQ_AAAA) &&
 704     getenv("CURL_DBG_RESOLV_FAIL_IPV6")) {
 705    infof(data, "DEBUG fail ipv6 resolve");
 706    result = hostip_resolv_failed(data, hostname, for_proxy);
 707    goto out;
 708  }
 709#endif
 710  /* Let's check our DNS cache first */
 711  result = Curl_dnscache_get(data, dns_queries, hostname, port, pdns);
 712  if(*pdns) {
 713    infof(data, "Hostname %s was found in DNS cache", hostname);
 714    result = CURLE_OK;
 715  }
 716  else if(result) {
 717    infof(data, "Negative DNS entry");
 718    result = hostip_resolv_failed(data, hostname, for_proxy);
 719  }
 720  else {
 721    /* No luck, we need to start resolving. */
 722    cache_dns = TRUE;
 723    result = hostip_resolv_start(data, dns_queries, hostname, port,
 724                                 transport, for_proxy, timeout_ms, allowDOH,
 725                                 presolv_id, pdns);
 726  }
 727
 728out:
 729  if(result && (result != CURLE_AGAIN)) {
 730    Curl_dns_entry_unlink(data, pdns);
 731    if(IS_RESOLV_FAIL(result)) {
 732      if(cache_dns)
 733        Curl_dnscache_add_negative(data, dns_queries, hostname, port);
 734      failf(data, "Could not resolve: %s:%u", hostname, port);
 735    }
 736    else {
 737      failf(data, "Error %d resolving %s:%u", result, hostname, port);
 738    }
 739  }
 740  else if(cache_dns && *pdns) {
 741    result = Curl_dnscache_add(data, *pdns);
 742    if(result)
 743      Curl_dns_entry_unlink(data, pdns);
 744  }
 745
 746  return result;
 747}
 748
 749CURLcode Curl_resolv_blocking(struct Curl_easy *data,
 750                              uint8_t dns_queries,
 751                              const char *hostname,
 752                              uint16_t port,
 753                              uint8_t transport,
 754                              struct Curl_dns_entry **pdns)
 755{
 756  CURLcode result;
 757  uint32_t resolv_id;
 758  DEBUGASSERT(hostname && *hostname);
 759  *pdns = NULL;
 760  /* We cannot do a blocking resolve using DoH currently */
 761  result = hostip_resolv(data, dns_queries,
 762                         hostname, port, transport, FALSE, 0, FALSE,
 763                         &resolv_id, pdns);
 764  switch(result) {
 765  case CURLE_OK:
 766    DEBUGASSERT(*pdns);
 767    break;
 768#ifdef USE_CURL_ASYNC
 769  case CURLE_AGAIN:
 770    DEBUGASSERT(!*pdns);
 771    result = Curl_async_await(data, resolv_id, pdns);
 772    Curl_resolv_destroy(data, resolv_id);
 773    break;
 774#endif
 775  default:
 776    break;
 777  }
 778  return result;
 779}
 780
 781#ifdef USE_ALARM_TIMEOUT
 782/*
 783 * This signal handler jumps back into the main libcurl code and continues
 784 * execution. This effectively causes the remainder of the application to run
 785 * within a signal handler which is nonportable and could lead to problems.
 786 */
 787CURL_NORETURN static void alarmfunc(int sig)
 788{
 789  (void)sig;
 790  siglongjmp(curl_jmpenv, 1);
 791}
 792
 793static CURLcode resolv_alarm_timeout(struct Curl_easy *data,
 794                                     uint8_t dns_queries,
 795                                     const char *hostname,
 796                                     uint16_t port,
 797                                     uint8_t transport,
 798                                     bool for_proxy,
 799                                     timediff_t timeout_ms,
 800                                     uint32_t *presolv_id,
 801                                     struct Curl_dns_entry **entry)
 802{
 803#ifdef HAVE_SIGACTION
 804  struct sigaction keep_sigact; /* store the old struct here */
 805  volatile bool keep_copysig = FALSE; /* whether old sigact has been saved */
 806  struct sigaction sigact;
 807#else
 808#ifdef HAVE_SIGNAL
 809  void (*keep_sigact)(int);       /* store the old handler here */
 810#endif /* HAVE_SIGNAL */
 811#endif /* HAVE_SIGACTION */
 812  volatile long timeout;
 813  volatile unsigned int prev_alarm = 0;
 814  CURLcode result;
 815
 816  DEBUGASSERT(hostname && *hostname);
 817  DEBUGASSERT(timeout_ms > 0);
 818  DEBUGASSERT(!data->set.no_signal);
 819#ifndef CURL_DISABLE_DOH
 820  DEBUGASSERT(!data->set.doh);
 821#endif
 822
 823  *entry = NULL;
 824  timeout = (timeout_ms > LONG_MAX) ? LONG_MAX : (long)timeout_ms;
 825  if(timeout < 1000) {
 826    /* The alarm() function only provides integer second resolution, so if
 827       we want to wait less than one second we must bail out already now. */
 828    failf(data,
 829          "remaining timeout of %ld too small to resolve via SIGALRM method",
 830          timeout);
 831    return CURLE_OPERATION_TIMEDOUT;
 832  }
 833  /* This allows us to time-out from the name resolver, as the timeout
 834     will generate a signal and we will siglongjmp() from that here.
 835     This technique has problems (see alarmfunc).
 836     This should be the last thing we do before calling Curl_resolv(),
 837     as otherwise we would have to worry about variables that get modified
 838     before we invoke Curl_resolv() (and thus use "volatile"). */
 839  curl_simple_lock_lock(&curl_jmpenv_lock);
 840
 841  if(sigsetjmp(curl_jmpenv, 1)) {
 842    /* this is coming from a siglongjmp() after an alarm signal */
 843    failf(data, "name lookup timed out");
 844    result = CURLE_OPERATION_TIMEDOUT;
 845    goto clean_up;
 846  }
 847  else {
 848    /*************************************************************
 849     * Set signal handler to catch SIGALRM
 850     * Store the old value to be able to set it back later!
 851     *************************************************************/
 852#ifdef HAVE_SIGACTION
 853    sigaction(SIGALRM, NULL, &sigact);
 854    keep_sigact = sigact;
 855    keep_copysig = TRUE; /* yes, we have a copy */
 856    sigact.sa_handler = alarmfunc;
 857#ifdef SA_RESTART
 858    /* HP-UX does not have SA_RESTART but defaults to that behavior! */
 859    sigact.sa_flags &= ~SA_RESTART;
 860#endif
 861    /* now set the new struct */
 862    sigaction(SIGALRM, &sigact, NULL);
 863#else /* HAVE_SIGACTION */
 864    /* no sigaction(), revert to the much lamer signal() */
 865#ifdef HAVE_SIGNAL
 866    keep_sigact = signal(SIGALRM, alarmfunc);
 867#endif
 868#endif /* HAVE_SIGACTION */
 869
 870    /* alarm() makes a signal get sent when the timeout fires off, and that
 871       will abort system calls */
 872    prev_alarm = alarm(curlx_sltoui(timeout / 1000L));
 873  }
 874
 875  /* Perform the actual name resolution. This might be interrupted by an
 876   * alarm if it takes too long. */
 877  result = hostip_resolv(data, dns_queries, hostname, port, transport,
 878                         for_proxy, timeout_ms, FALSE, presolv_id, entry);
 879
 880clean_up:
 881  if(!prev_alarm)
 882    /* deactivate a possibly active alarm before uninstalling the handler */
 883    alarm(0);
 884
 885#ifdef HAVE_SIGACTION
 886  if(keep_copysig) {
 887    /* we got a struct as it looked before, now put that one back nice
 888       and clean */
 889    sigaction(SIGALRM, &keep_sigact, NULL); /* put it back */
 890  }
 891#else
 892#ifdef HAVE_SIGNAL
 893  /* restore the previous SIGALRM handler */
 894  signal(SIGALRM, keep_sigact);
 895#endif
 896#endif /* HAVE_SIGACTION */
 897
 898  curl_simple_lock_unlock(&curl_jmpenv_lock);
 899
 900  /* switch back the alarm() to either zero or to what it was before minus
 901     the time we spent until now! */
 902  if(prev_alarm) {
 903    /* there was an alarm() set before us, now put it back */
 904    timediff_t elapsed_secs = curlx_ptimediff_ms(Curl_pgrs_now(data),
 905                                                 &data->conn->created) / 1000;
 906
 907    /* the alarm period is counted in even number of seconds */
 908    unsigned long alarm_set = (unsigned long)(prev_alarm - elapsed_secs);
 909
 910    if(!alarm_set ||
 911       ((alarm_set >= 0x80000000) && (prev_alarm < 0x80000000))) {
 912      /* if the alarm time-left reached zero or turned "negative" (counted
 913         with unsigned values), we should fire off a SIGALRM here, but we
 914         will not, and zero would be to switch it off so we never set it to
 915         less than 1! */
 916      alarm(1);
 917      result = CURLE_OPERATION_TIMEDOUT;
 918      failf(data, "Previous alarm fired off");
 919    }
 920    else
 921      alarm((unsigned int)alarm_set);
 922  }
 923
 924  return result;
 925}
 926
 927#endif /* USE_ALARM_TIMEOUT */
 928
 929#ifdef USE_UNIX_SOCKETS
 930static CURLcode resolv_unix(struct Curl_easy *data,
 931                            const char *unix_path,
 932                            bool abstract_path,
 933                            struct Curl_dns_entry **pdns)
 934{
 935  struct Curl_addrinfo *addr;
 936  CURLcode result;
 937
 938  DEBUGASSERT(unix_path);
 939  *pdns = NULL;
 940
 941  result = Curl_unix2addr(unix_path, abstract_path, &addr);
 942  if(result) {
 943    if(result == CURLE_TOO_LARGE) {
 944      /* Long paths are not supported for now */
 945      failf(data, "Unix socket path too long: '%s'", unix_path);
 946      result = CURLE_COULDNT_RESOLVE_HOST;
 947    }
 948    return result;
 949  }
 950
 951  *pdns = Curl_dnscache_mk_entry(data, 0, &addr, NULL, 0);
 952  return *pdns ? CURLE_OK : CURLE_OUT_OF_MEMORY;
 953}
 954#endif /* USE_UNIX_SOCKETS */
 955
 956/*
 957 * Curl_resolv() is the main name resolve function within libcurl. It resolves
 958 * a name and returns a pointer to the entry in the 'entry' argument. This
 959 * function might return immediately if we are using asynch resolves. See the
 960 * return codes.
 961 *
 962 * The cache entry we return will get its 'inuse' counter increased when this
 963 * function is used. You MUST call Curl_dns_entry_unlink() later (when you are
 964 * done using this struct) to decrease the reference counter again.
 965 *
 966 * If built with a synchronous resolver and use of signals is not
 967 * disabled by the application, then a nonzero timeout will cause a
 968 * timeout after the specified number of milliseconds. Otherwise, timeout
 969 * is ignored.
 970 *
 971 * Return codes:
 972 * CURLE_OK = success, *pdns set to non-NULL
 973 * CURLE_AGAIN = resolving in progress, *pdns == NULL
 974 * any other CURLcode error, *pdns == NULL
 975 */
 976CURLcode Curl_resolv(struct Curl_easy *data,
 977                     struct Curl_peer *peer,
 978                     uint8_t dns_queries,
 979                     uint8_t transport,
 980                     bool for_proxy,
 981                     timediff_t timeout_ms,
 982                     uint32_t *presolv_id,
 983                     struct Curl_dns_entry **pdns)
 984{
 985  *presolv_id = 0;
 986  *pdns = NULL;
 987
 988  if(timeout_ms < 0)
 989    /* got an already expired timeout */
 990    return CURLE_OPERATION_TIMEDOUT;
 991  else if(!timeout_ms)
 992    timeout_ms = CURL_TIMEOUT_RESOLVE_MS;
 993
 994#ifdef USE_UNIX_SOCKETS
 995  if(peer->unix_socket)
 996    return resolv_unix(data, peer->hostname, (bool)peer->abstract_uds, pdns);
 997#else
 998  if(peer->unix_socket)
 999    return hostip_resolv_failed(data, peer->hostname, for_proxy);
1000#endif
1001
1002#ifdef USE_ALARM_TIMEOUT
1003  if(timeout_ms && data->set.no_signal) {
1004    /* Cannot use ALARM when signals are disabled */
1005    timeout_ms = 0;
1006  }
1007  if(timeout_ms && !Curl_doh_wanted(data)) {
1008    return resolv_alarm_timeout(data, dns_queries, peer->hostname, peer->port,
1009                                transport, for_proxy, timeout_ms, presolv_id,
1010                                pdns);
1011  }
1012#endif /* !USE_ALARM_TIMEOUT */
1013
1014#ifndef CURLRES_ASYNCH
1015  if(timeout_ms)
1016    infof(data, "timeout on name lookup is not supported");
1017#endif
1018
1019  return hostip_resolv(data, dns_queries, peer->hostname, peer->port,
1020                       transport, for_proxy, timeout_ms, TRUE, presolv_id,
1021                       pdns);
1022}
1023
1024#ifdef USE_CURL_ASYNC
1025
1026struct Curl_resolv_async *Curl_async_get(struct Curl_easy *data,
1027                                         uint32_t resolv_id)
1028{
1029  struct Curl_resolv_async *async = data->state.async;
1030  for(; async; async = async->next) {
1031    if(async->id == resolv_id)
1032      return async;
1033  }
1034  return NULL;
1035}
1036
1037CURLcode Curl_resolv_take_result(struct Curl_easy *data, uint32_t resolv_id,
1038                                 struct Curl_dns_entry **pdns)
1039{
1040  struct Curl_resolv_async *async = Curl_async_get(data, resolv_id);
1041  CURLcode result;
1042
1043  /* If async resolving is ongoing, this must be set */
1044  if(!async)
1045    return CURLE_FAILED_INIT;
1046
1047  /* check if we have the name resolved by now (from someone else) */
1048  result = Curl_dnscache_get(data, async->dns_queries,
1049                             async->hostname, async->port, pdns);
1050  if(*pdns) {
1051    /* Tell a possibly async resolver we no longer need the results. */
1052    infof(data, "Hostname '%s' was found in DNS cache", async->hostname);
1053    Curl_async_shutdown(data, async);
1054    return CURLE_OK;
1055  }
1056  else if(result) {
1057    Curl_async_shutdown(data, async);
1058    return Curl_async_failed(data, async, NULL);
1059  }
1060
1061  result = hostip_resolv_take_result(data, async, pdns);
1062
1063  if(*pdns) {
1064    /* Add to cache */
1065    result = Curl_dnscache_add(data, *pdns);
1066    if(result)
1067      Curl_dns_entry_unlink(data, pdns);
1068  }
1069  else if(IS_RESOLV_FAIL(result)) {
1070    Curl_dnscache_add_negative(data, async->dns_queries,
1071                               async->hostname, async->port);
1072    failf(data, "Could not resolve: %s:%u", async->hostname, async->port);
1073  }
1074  else if(result) {
1075    failf(data, "Error %d resolving %s:%u",
1076          result, async->hostname, async->port);
1077  }
1078  return result;
1079}
1080
1081CURLcode Curl_resolv_pollset(struct Curl_easy *data,
1082                             struct easy_pollset *ps)
1083{
1084  struct Curl_resolv_async *async = data->state.async;
1085  CURLcode result = CURLE_OK;
1086
1087  (void)ps;
1088  for(; async && !result; async = async->next) {
1089#ifndef CURL_DISABLE_DOH
1090    if(async->doh) /* DoH has nothing for the pollset */
1091      continue;
1092#endif
1093    result = Curl_async_pollset(data, async, ps);
1094  }
1095  return result;
1096}
1097
1098void Curl_resolv_destroy(struct Curl_easy *data, uint32_t resolv_id)
1099{
1100  struct Curl_resolv_async **panchor = &data->state.async;
1101
1102  for(; *panchor; panchor = &(*panchor)->next) {
1103    struct Curl_resolv_async *async = *panchor;
1104    if(async->id == resolv_id) {
1105      *panchor = async->next;
1106      Curl_async_destroy(data, async);
1107      break;
1108    }
1109  }
1110}
1111
1112void Curl_resolv_shutdown_all(struct Curl_easy *data)
1113{
1114  struct Curl_resolv_async *async = data->state.async;
1115  for(; async; async = async->next) {
1116    Curl_async_shutdown(data, async);
1117  }
1118}
1119
1120void Curl_resolv_destroy_all(struct Curl_easy *data)
1121{
1122  while(data->state.async) {
1123    struct Curl_resolv_async *async = data->state.async;
1124    data->state.async = async->next;
1125    Curl_async_destroy(data, async);
1126  }
1127}
1128
1129#endif /* USE_CURL_ASYNC */