luna - curl/lib/doh.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#ifndef CURL_DISABLE_DOH
  27
  28#include "urldata.h"
  29#include "curl_addrinfo.h"
  30#include "doh.h"
  31#include "curl_trc.h"
  32#include "httpsrr.h"
  33#include "multiif.h"
  34#include "url.h"
  35#include "connect.h"
  36#include "curlx/strdup.h"
  37#include "curlx/dynbuf.h"
  38#include "escape.h"  /* for Curl_hexencode() */
  39#include "urlapi-int.h"
  40
  41#define DNS_CLASS_IN 0x01
  42
  43static void doh_close(struct Curl_easy *data,
  44                      struct Curl_resolv_async *async);
  45
  46#ifdef CURLVERBOSE
  47static const char * const errors[] = {
  48  "",
  49  "Bad label",
  50  "Out of range",
  51  "Label loop",
  52  "Too small",
  53  "Out of memory",
  54  "RDATA length",
  55  "Malformat",
  56  "Bad RCODE",
  57  "Unexpected TYPE",
  58  "Unexpected CLASS",
  59  "No content",
  60  "Bad ID",
  61  "Name too long"
  62};
  63
  64static const char *doh_strerror(DOHcode code)
  65{
  66  if((code >= DOH_OK) && (code <= DOH_DNS_NAME_TOO_LONG))
  67    return errors[code];
  68  return "bad error code";
  69}
  70
  71#endif /* CURLVERBOSE */
  72
  73/* @unittest 1655
  74 */
  75UNITTEST DOHcode doh_req_encode(const char *host,
  76                                DNStype dnstype,
  77                                unsigned char *dnsp,  /* buffer */
  78                                size_t len,  /* buffer size */
  79                                size_t *olen);  /* output length */
  80UNITTEST DOHcode doh_req_encode(const char *host,
  81                                DNStype dnstype,
  82                                unsigned char *dnsp, /* buffer */
  83                                size_t len,   /* buffer size */
  84                                size_t *olen) /* output length */
  85{
  86  const size_t hostlen = strlen(host);
  87  unsigned char *orig = dnsp;
  88  const char *hostp = host;
  89
  90  /* The expected output length is 16 bytes more than the length of
  91   * the QNAME-encoding of the hostname.
  92   *
  93   * A valid DNS name may not contain a zero-length label, except at
  94   * the end. For this reason, a name beginning with a dot, or
  95   * containing a sequence of two or more consecutive dots, is invalid
  96   * and cannot be encoded as a QNAME.
  97   *
  98   * If the hostname ends with a trailing dot, the corresponding
  99   * QNAME-encoding is one byte longer than the hostname. If (as is
 100   * also valid) the hostname is shortened by the omission of the
 101   * trailing dot, then its QNAME-encoding will be two bytes longer
 102   * than the hostname.
 103   *
 104   * Each [ label, dot ] pair is encoded as [ length, label ],
 105   * preserving overall length. A final [ label ] without a dot is
 106   * also encoded as [ length, label ], increasing overall length
 107   * by one. The encoding is completed by appending a zero byte,
 108   * representing the zero-length root label, again increasing
 109   * the overall length by one.
 110   */
 111
 112  size_t expected_len;
 113  DEBUGASSERT(hostlen);
 114  expected_len = 12 + 1 + hostlen + 4;
 115  if(host[hostlen - 1] != '.')
 116    expected_len++;
 117
 118  if(expected_len > DOH_MAX_DNSREQ_SIZE)
 119    return DOH_DNS_NAME_TOO_LONG;
 120
 121  if(len < expected_len)
 122    return DOH_TOO_SMALL_BUFFER;
 123
 124  *dnsp++ = 0; /* 16-bit id */
 125  *dnsp++ = 0;
 126  *dnsp++ = 0x01; /* |QR|   Opcode  |AA|TC|RD| Set the RD bit */
 127  *dnsp++ = '\0'; /* |RA|   Z    |   RCODE   |                */
 128  *dnsp++ = '\0';
 129  *dnsp++ = 1;    /* QDCOUNT (number of entries in the question section) */
 130  *dnsp++ = '\0';
 131  *dnsp++ = '\0'; /* ANCOUNT */
 132  *dnsp++ = '\0';
 133  *dnsp++ = '\0'; /* NSCOUNT */
 134  *dnsp++ = '\0';
 135  *dnsp++ = '\0'; /* ARCOUNT */
 136
 137  /* encode each label and store it in the QNAME */
 138  while(*hostp) {
 139    size_t labellen;
 140    const char *dot = strchr(hostp, '.');
 141    if(dot)
 142      labellen = dot - hostp;
 143    else
 144      labellen = strlen(hostp);
 145    if((labellen > 63) || (!labellen)) {
 146      /* label is too long or too short, error out */
 147      *olen = 0;
 148      return DOH_DNS_BAD_LABEL;
 149    }
 150    /* label is non-empty, process it */
 151    *dnsp++ = (unsigned char)labellen;
 152    memcpy(dnsp, hostp, labellen);
 153    dnsp += labellen;
 154    hostp += labellen;
 155    /* advance past dot, but only if there is one */
 156    if(dot)
 157      hostp++;
 158  } /* next label */
 159
 160  *dnsp++ = 0; /* append zero-length label for root */
 161
 162  /* There are assigned TYPE codes beyond 255: use range [1..65535] */
 163  *dnsp++ = (unsigned char)(255 & (dnstype >> 8)); /* upper 8-bit TYPE */
 164  *dnsp++ = (unsigned char)(255 & dnstype);        /* lower 8-bit TYPE */
 165
 166  *dnsp++ = '\0'; /* upper 8-bit CLASS */
 167  *dnsp++ = DNS_CLASS_IN; /* IN - "the Internet" */
 168
 169  *olen = dnsp - orig;
 170
 171  /* verify that our estimation of length is valid, since
 172   * this has led to buffer overflows in this function */
 173  DEBUGASSERT(*olen == expected_len);
 174  return DOH_OK;
 175}
 176
 177static size_t doh_probe_write_cb(char *contents, size_t size, size_t nmemb,
 178                                 void *userp)
 179{
 180  size_t realsize = size * nmemb;
 181  struct Curl_easy *data = userp;
 182  struct doh_request *doh_req = Curl_meta_get(data, CURL_EZM_DOH_PROBE);
 183  if(!doh_req)
 184    return CURL_WRITEFUNC_ERROR;
 185
 186  if(curlx_dyn_addn(&doh_req->resp_body, contents, realsize))
 187    return 0;
 188
 189  return realsize;
 190}
 191
 192#if defined(USE_HTTPSRR) && defined(DEBUGBUILD) && defined(CURLVERBOSE)
 193
 194/* doh_print_buf truncates if the hex string will be more than this */
 195#define LOCAL_PB_HEXMAX 400
 196
 197static void doh_print_buf(struct Curl_easy *data,
 198                          const char *prefix,
 199                          unsigned char *buf, size_t len)
 200{
 201  unsigned char hexstr[LOCAL_PB_HEXMAX];
 202  size_t hlen = LOCAL_PB_HEXMAX;
 203  bool truncated = FALSE;
 204
 205  if(len > (LOCAL_PB_HEXMAX / 2))
 206    truncated = TRUE;
 207  Curl_hexencode(buf, len, hexstr, hlen);
 208  if(!truncated)
 209    infof(data, "%s: len=%d, val=%s", prefix, (int)len, hexstr);
 210  else
 211    infof(data, "%s: len=%d (truncated)val=%s", prefix, (int)len, hexstr);
 212}
 213#endif
 214
 215/* called from multi when a sub transfer, e.g. doh probe, is done.
 216 * This looks up the probe response at its meta CURL_EZM_DOH_PROBE
 217 * and copies the response body over to the struct at the master's
 218 * meta at CURL_EZM_DOH_MASTER. */
 219static void doh_probe_done(struct Curl_easy *data,
 220                           struct Curl_easy *doh, CURLcode result)
 221{
 222  struct Curl_resolv_async *async = NULL;
 223  struct doh_probes *dohp = NULL;
 224  struct doh_request *doh_req = NULL;
 225  int i;
 226
 227  doh_req = Curl_meta_get(doh, CURL_EZM_DOH_PROBE);
 228  if(!doh_req) {
 229    DEBUGASSERT(0);
 230    return;
 231  }
 232
 233  async = Curl_async_get(data, doh_req->resolv_id);
 234  if(!async) {
 235    CURL_TRC_DNS(data, "[%u] ignoring outdated DoH response",
 236                 doh_req->resolv_id);
 237    return;
 238  }
 239  dohp = async->doh;
 240
 241  for(i = 0; i < DOH_SLOT_COUNT; ++i) {
 242    if(dohp->probe_resp[i].probe_mid == doh->mid)
 243      break;
 244  }
 245  /* We really should have found the slot where to store the response */
 246  if(i >= DOH_SLOT_COUNT) {
 247    DEBUGASSERT(0);
 248    failf(data, "DoH: unknown sub request done");
 249    return;
 250  }
 251
 252  dohp->pending--;
 253  infof(doh, "a DoH request is completed, %u to go", dohp->pending);
 254  dohp->probe_resp[i].result = result;
 255  /* We expect either the meta data still to exist or the sub request
 256   * to have already failed. */
 257  if(!result) {
 258    dohp->probe_resp[i].dnstype = doh_req->dnstype;
 259    result = curlx_dyn_addn(&dohp->probe_resp[i].body,
 260                            curlx_dyn_ptr(&doh_req->resp_body),
 261                            curlx_dyn_len(&doh_req->resp_body));
 262    curlx_dyn_free(&doh_req->resp_body);
 263  }
 264  Curl_meta_remove(doh, CURL_EZM_DOH_PROBE);
 265
 266  if(result)
 267    infof(doh, "DoH request %s", curl_easy_strerror(result));
 268
 269  if(!dohp->pending) {
 270    /* DoH completed, run the transfer picking up the results */
 271    Curl_multi_mark_dirty(data);
 272  }
 273}
 274
 275static void doh_probe_dtor(void *key, size_t klen, void *e)
 276{
 277  (void)key;
 278  (void)klen;
 279  if(e) {
 280    struct doh_request *doh_req = e;
 281    curl_slist_free_all(doh_req->req_hds);
 282    curlx_dyn_free(&doh_req->resp_body);
 283    curlx_free(e);
 284  }
 285}
 286
 287#define ERROR_CHECK_SETOPT(x, y)                        \
 288  do {                                                  \
 289    result = curl_easy_setopt((CURL *)doh, x, y);       \
 290    if(result &&                                        \
 291       result != CURLE_NOT_BUILT_IN &&                  \
 292       result != CURLE_UNKNOWN_OPTION)                  \
 293      goto error;                                       \
 294  } while(0)
 295
 296static CURLcode doh_probe_run(struct Curl_easy *data,
 297                              DNStype dnstype,
 298                              const char *host,
 299                              const char *url, CURLM *multi,
 300                              uint32_t resolv_id,
 301                              uint32_t *pmid)
 302{
 303  struct Curl_easy *doh = NULL;
 304  CURLcode result = CURLE_OK;
 305  timediff_t timeout_ms;
 306  struct doh_request *doh_req;
 307  DOHcode d;
 308
 309  *pmid = UINT32_MAX;
 310
 311  doh_req = curlx_calloc(1, sizeof(*doh_req));
 312  if(!doh_req)
 313    return CURLE_OUT_OF_MEMORY;
 314  doh_req->resolv_id = resolv_id;
 315  doh_req->dnstype = dnstype;
 316  curlx_dyn_init(&doh_req->resp_body, DYN_DOH_RESPONSE);
 317
 318  d = doh_req_encode(host, dnstype, doh_req->req_body,
 319                     sizeof(doh_req->req_body),
 320                     &doh_req->req_body_len);
 321  if(d) {
 322    failf(data, "Failed to encode DoH packet [%d]", d);
 323    result = CURLE_OUT_OF_MEMORY;
 324    goto error;
 325  }
 326
 327  timeout_ms = Curl_timeleft_ms(data);
 328  if(timeout_ms < 0) {
 329    result = CURLE_OPERATION_TIMEDOUT;
 330    goto error;
 331  }
 332
 333  doh_req->req_hds =
 334    curl_slist_append(NULL, "Content-Type: application/dns-message");
 335  if(!doh_req->req_hds) {
 336    result = CURLE_OUT_OF_MEMORY;
 337    goto error;
 338  }
 339
 340  /* Curl_open() is the internal version of curl_easy_init() */
 341  result = Curl_open(&doh);
 342  if(result)
 343    goto error;
 344
 345  /* pass in the struct pointer via a local variable to please coverity and
 346     the gcc typecheck helpers */
 347  VERBOSE(doh->state.feat = &Curl_trc_feat_dns);
 348  ERROR_CHECK_SETOPT(CURLOPT_URL, url);
 349  ERROR_CHECK_SETOPT(CURLOPT_DEFAULT_PROTOCOL, "https");
 350  ERROR_CHECK_SETOPT(CURLOPT_WRITEFUNCTION, doh_probe_write_cb);
 351  ERROR_CHECK_SETOPT(CURLOPT_WRITEDATA, doh);
 352  ERROR_CHECK_SETOPT(CURLOPT_POSTFIELDS, doh_req->req_body);
 353  ERROR_CHECK_SETOPT(CURLOPT_POSTFIELDSIZE, (long)doh_req->req_body_len);
 354  ERROR_CHECK_SETOPT(CURLOPT_HTTPHEADER, doh_req->req_hds);
 355#ifdef USE_HTTP2
 356  ERROR_CHECK_SETOPT(CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2TLS);
 357  ERROR_CHECK_SETOPT(CURLOPT_PIPEWAIT, 1L);
 358#endif
 359#ifndef DEBUGBUILD
 360  /* enforce HTTPS if not debug */
 361  ERROR_CHECK_SETOPT(CURLOPT_PROTOCOLS, CURLPROTO_HTTPS);
 362#else
 363  /* in debug mode, also allow http */
 364  ERROR_CHECK_SETOPT(CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
 365#endif
 366  ERROR_CHECK_SETOPT(CURLOPT_TIMEOUT_MS, (long)timeout_ms);
 367  ERROR_CHECK_SETOPT(CURLOPT_SHARE, (CURLSH *)data->share);
 368  if(data->set.err && data->set.err != stderr)
 369    ERROR_CHECK_SETOPT(CURLOPT_STDERR, data->set.err);
 370  if(Curl_trc_ft_is_verbose(data, &Curl_trc_feat_dns))
 371    ERROR_CHECK_SETOPT(CURLOPT_VERBOSE, 1L);
 372  if(data->set.no_signal)
 373    ERROR_CHECK_SETOPT(CURLOPT_NOSIGNAL, 1L);
 374
 375  ERROR_CHECK_SETOPT(CURLOPT_SSL_VERIFYHOST,
 376                     data->set.doh_verifyhost ? 2L : 0L);
 377  ERROR_CHECK_SETOPT(CURLOPT_SSL_VERIFYPEER,
 378                     data->set.doh_verifypeer ? 1L : 0L);
 379  ERROR_CHECK_SETOPT(CURLOPT_SSL_VERIFYSTATUS,
 380                     data->set.doh_verifystatus ? 1L : 0L);
 381
 382  /* Inherit *some* SSL options from the user's transfer. This is a
 383     best-guess as to which options are needed for compatibility. #3661
 384
 385     Note DoH does not inherit the user's proxy server so proxy SSL settings
 386     have no effect and are not inherited. If that changes then two new
 387     options should be added to check doh proxy insecure separately,
 388     CURLOPT_DOH_PROXY_SSL_VERIFYHOST and CURLOPT_DOH_PROXY_SSL_VERIFYPEER.
 389     */
 390  doh->set.ssl.custom_cafile = data->set.ssl.custom_cafile;
 391  doh->set.ssl.custom_capath = data->set.ssl.custom_capath;
 392  doh->set.ssl.custom_cablob = data->set.ssl.custom_cablob;
 393  if(data->set.str[STRING_SSL_CAFILE]) {
 394    ERROR_CHECK_SETOPT(CURLOPT_CAINFO, data->set.str[STRING_SSL_CAFILE]);
 395  }
 396  if(data->set.blobs[BLOB_CAINFO]) {
 397    ERROR_CHECK_SETOPT(CURLOPT_CAINFO_BLOB, data->set.blobs[BLOB_CAINFO]);
 398  }
 399  if(data->set.str[STRING_SSL_CAPATH]) {
 400    ERROR_CHECK_SETOPT(CURLOPT_CAPATH, data->set.str[STRING_SSL_CAPATH]);
 401  }
 402  if(data->set.str[STRING_SSL_CRLFILE]) {
 403    ERROR_CHECK_SETOPT(CURLOPT_CRLFILE, data->set.str[STRING_SSL_CRLFILE]);
 404  }
 405  if(data->set.ssl.certinfo)
 406    ERROR_CHECK_SETOPT(CURLOPT_CERTINFO, 1L);
 407  if(data->set.ssl.fsslctx)
 408    ERROR_CHECK_SETOPT(CURLOPT_SSL_CTX_FUNCTION, data->set.ssl.fsslctx);
 409  if(data->set.ssl.fsslctxp)
 410    ERROR_CHECK_SETOPT(CURLOPT_SSL_CTX_DATA, data->set.ssl.fsslctxp);
 411  if(data->set.fdebug)
 412    ERROR_CHECK_SETOPT(CURLOPT_DEBUGFUNCTION, data->set.fdebug);
 413  if(data->set.debugdata)
 414    ERROR_CHECK_SETOPT(CURLOPT_DEBUGDATA, data->set.debugdata);
 415  if(data->set.str[STRING_SSL_EC_CURVES]) {
 416    ERROR_CHECK_SETOPT(CURLOPT_SSL_EC_CURVES,
 417                       data->set.str[STRING_SSL_EC_CURVES]);
 418  }
 419
 420  (void)curl_easy_setopt(doh, CURLOPT_SSL_OPTIONS,
 421                         (long)data->set.ssl.primary.ssl_options);
 422
 423  doh->state.internal = TRUE;
 424  doh->master_mid = data->mid; /* master transfer of this one */
 425
 426  result = Curl_meta_set(doh, CURL_EZM_DOH_PROBE, doh_req, doh_probe_dtor);
 427  doh_req = NULL; /* call took ownership */
 428  if(result)
 429    goto error;
 430
 431  /* DoH handles must not inherit private_data. The handles may be passed to
 432     the user via callbacks and the user will be able to identify them as
 433     internal handles because private data is not set. The user can then set
 434     private_data via CURLOPT_PRIVATE if they so choose. */
 435  DEBUGASSERT(!doh->set.private_data);
 436
 437  if(curl_multi_add_handle(multi, doh))
 438    goto error;
 439
 440  *pmid = doh->mid;
 441  return CURLE_OK;
 442
 443error:
 444  Curl_close(&doh);
 445  if(doh_req)
 446    doh_probe_dtor(NULL, 0, doh_req);
 447  return result;
 448}
 449
 450/*
 451 * Curl_doh() starts a name resolve using DoH. It resolves a name and returns
 452 * a 'Curl_addrinfo *' with the address information.
 453 */
 454
 455CURLcode Curl_doh(struct Curl_easy *data,
 456                  struct Curl_resolv_async *async)
 457{
 458  CURLcode result = CURLE_OK;
 459  struct doh_probes *dohp = NULL;
 460  size_t i;
 461
 462  DEBUGASSERT(!async->doh);
 463  DEBUGASSERT(async->hostname[0]);
 464  if(async->doh) {
 465    DEBUGASSERT(0); /* should not happen */
 466    Curl_doh_cleanup(data, async);
 467  }
 468
 469  /* start clean, consider allocating this struct on demand */
 470  async->doh = dohp = curlx_calloc(1, sizeof(struct doh_probes));
 471  if(!dohp)
 472    return CURLE_OUT_OF_MEMORY;
 473
 474  for(i = 0; i < DOH_SLOT_COUNT; ++i) {
 475    dohp->probe_resp[i].probe_mid = UINT32_MAX;
 476    curlx_dyn_init(&dohp->probe_resp[i].body, DYN_DOH_RESPONSE);
 477  }
 478
 479  dohp->host = async->hostname;
 480  dohp->port = async->port;
 481  /* We are making sub easy handles and want to be called back when
 482   * one is done. */
 483  data->sub_xfer_done = doh_probe_done;
 484
 485  /* create IPv4 DoH request */
 486  if(async->dns_queries & CURL_DNSQ_A) {
 487    result = doh_probe_run(data, CURL_DNS_TYPE_A,
 488                           async->hostname, data->set.str[STRING_DOH],
 489                           data->multi, async->id,
 490                           &dohp->probe_resp[DOH_SLOT_IPV4].probe_mid);
 491    if(result)
 492      goto error;
 493    dohp->pending++;
 494  }
 495
 496#ifdef USE_IPV6
 497  if(async->dns_queries & CURL_DNSQ_AAAA) {
 498    /* create IPv6 DoH request */
 499    result = doh_probe_run(data, CURL_DNS_TYPE_AAAA,
 500                           async->hostname, data->set.str[STRING_DOH],
 501                           data->multi, async->id,
 502                           &dohp->probe_resp[DOH_SLOT_IPV6].probe_mid);
 503    if(result)
 504      goto error;
 505    dohp->pending++;
 506  }
 507#endif
 508
 509#ifdef USE_HTTPSRR
 510  if(async->dns_queries & CURL_DNSQ_HTTPS) {
 511    char *qname = NULL;
 512    if(async->port != PORT_HTTPS) {
 513      qname = curl_maprintf("_%d._https.%s", async->port, async->hostname);
 514      if(!qname)
 515        goto error;
 516    }
 517    result = doh_probe_run(data, CURL_DNS_TYPE_HTTPS,
 518                           qname ? qname : async->hostname,
 519                           data->set.str[STRING_DOH], data->multi,
 520                           async->id,
 521                           &dohp->probe_resp[DOH_SLOT_HTTPS_RR].probe_mid);
 522    curlx_free(qname);
 523    if(result)
 524      goto error;
 525    dohp->pending++;
 526  }
 527#endif
 528  return CURLE_OK;
 529
 530error:
 531  Curl_doh_cleanup(data, async);
 532  return result;
 533}
 534
 535static DOHcode doh_skipqname(const unsigned char *doh, size_t dohlen,
 536                             unsigned int *indexp)
 537{
 538  unsigned char length;
 539  do {
 540    if(dohlen < (*indexp + 1))
 541      return DOH_DNS_OUT_OF_RANGE;
 542    length = doh[*indexp];
 543    if((length & 0xc0) == 0xc0) {
 544      /* name pointer, advance over it and be done */
 545      if(dohlen < (*indexp + 2))
 546        return DOH_DNS_OUT_OF_RANGE;
 547      *indexp += 2;
 548      break;
 549    }
 550    if(length & 0xc0)
 551      return DOH_DNS_BAD_LABEL;
 552    if(dohlen < (*indexp + 1 + length))
 553      return DOH_DNS_OUT_OF_RANGE;
 554    *indexp += (unsigned int)(1 + length);
 555  } while(length);
 556  return DOH_OK;
 557}
 558
 559static unsigned short doh_get16bit(const unsigned char *doh,
 560                                   unsigned int index)
 561{
 562  return (unsigned short)((doh[index] << 8) | doh[index + 1]);
 563}
 564
 565static unsigned int doh_get32bit(const unsigned char *doh, unsigned int index)
 566{
 567  /* make clang and gcc optimize this to bswap by incrementing
 568     the pointer first. */
 569  doh += index;
 570
 571  /* avoid undefined behavior by casting to unsigned before shifting
 572     24 bits, possibly into the sign bit. codegen is same, but
 573     ub sanitizer will not be upset */
 574  return ((unsigned)doh[0] << 24) | ((unsigned)doh[1] << 16) |
 575         ((unsigned)doh[2] << 8) | doh[3];
 576}
 577
 578static void doh_store_a(const unsigned char *doh, int index,
 579                        struct dohentry *d)
 580{
 581  /* silently ignore addresses over the limit */
 582  if(d->numaddr < DOH_MAX_ADDR) {
 583    struct dohaddr *a = &d->addr[d->numaddr];
 584    a->type = CURL_DNS_TYPE_A;
 585    memcpy(&a->ip.v4, &doh[index], 4);
 586    d->numaddr++;
 587  }
 588}
 589
 590static void doh_store_aaaa(const unsigned char *doh, int index,
 591                           struct dohentry *d)
 592{
 593  /* silently ignore addresses over the limit */
 594  if(d->numaddr < DOH_MAX_ADDR) {
 595    struct dohaddr *a = &d->addr[d->numaddr];
 596    a->type = CURL_DNS_TYPE_AAAA;
 597    memcpy(&a->ip.v6, &doh[index], 16);
 598    d->numaddr++;
 599  }
 600}
 601
 602#ifdef USE_HTTPSRR
 603static DOHcode doh_store_https(const unsigned char *doh, int index,
 604                               struct dohentry *d, uint16_t len)
 605{
 606  /* silently ignore RRs over the limit */
 607  if(d->numhttps_rrs < DOH_MAX_HTTPS) {
 608    struct dohhttps_rr *h = &d->https_rrs[d->numhttps_rrs];
 609    h->val = curlx_memdup(&doh[index], len);
 610    if(!h->val)
 611      return DOH_OUT_OF_MEM;
 612    h->len = len;
 613    d->numhttps_rrs++;
 614  }
 615  return DOH_OK;
 616}
 617#endif
 618
 619static DOHcode doh_store_cname(const unsigned char *doh, size_t dohlen,
 620                               unsigned int index, struct dohentry *d)
 621{
 622  struct dynbuf *c;
 623  unsigned int loop = 128; /* a valid DNS name can never loop this much */
 624  unsigned char length;
 625
 626  if(d->numcname == DOH_MAX_CNAME)
 627    return DOH_OK; /* skip! */
 628
 629  c = &d->cname[d->numcname++];
 630  do {
 631    if(index >= dohlen)
 632      return DOH_DNS_OUT_OF_RANGE;
 633    length = doh[index];
 634    if((length & 0xc0) == 0xc0) {
 635      int newpos;
 636      /* name pointer, get the new offset (14 bits) */
 637      if((index + 1) >= dohlen)
 638        return DOH_DNS_OUT_OF_RANGE;
 639
 640      /* move to the new index */
 641      newpos = (length & 0x3f) << 8 | doh[index + 1];
 642      index = (unsigned int)newpos;
 643      continue;
 644    }
 645    else if(length & 0xc0)
 646      return DOH_DNS_BAD_LABEL; /* bad input */
 647    else
 648      index++;
 649
 650    if(length) {
 651      if(curlx_dyn_len(c)) {
 652        if(curlx_dyn_addn(c, STRCONST(".")))
 653          return DOH_OUT_OF_MEM;
 654      }
 655      if((index + length) > dohlen)
 656        return DOH_DNS_BAD_LABEL;
 657
 658      if(curlx_dyn_addn(c, &doh[index], length))
 659        return DOH_OUT_OF_MEM;
 660      index += length;
 661    }
 662  } while(length && --loop);
 663
 664  if(!loop)
 665    return DOH_DNS_LABEL_LOOP;
 666  return DOH_OK;
 667}
 668
 669static DOHcode doh_rdata(const unsigned char *doh,
 670                         size_t dohlen,
 671                         unsigned short rdlength,
 672                         unsigned short type,
 673                         int index,
 674                         struct dohentry *d)
 675{
 676  /* RDATA
 677     - A (TYPE 1): 4 bytes
 678     - AAAA (TYPE 28): 16 bytes
 679     - NS (TYPE 2): N bytes
 680     - HTTPS (TYPE 65): N bytes */
 681  DOHcode rc;
 682
 683  switch(type) {
 684  case CURL_DNS_TYPE_A:
 685    if(rdlength != 4)
 686      return DOH_DNS_RDATA_LEN;
 687    doh_store_a(doh, index, d);
 688    break;
 689  case CURL_DNS_TYPE_AAAA:
 690    if(rdlength != 16)
 691      return DOH_DNS_RDATA_LEN;
 692    doh_store_aaaa(doh, index, d);
 693    break;
 694#ifdef USE_HTTPSRR
 695  case CURL_DNS_TYPE_HTTPS:
 696    rc = doh_store_https(doh, index, d, rdlength);
 697    if(rc)
 698      return rc;
 699    break;
 700#endif
 701  case CURL_DNS_TYPE_CNAME:
 702    rc = doh_store_cname(doh, dohlen, (unsigned int)index, d);
 703    if(rc)
 704      return rc;
 705    break;
 706  case CURL_DNS_TYPE_DNAME:
 707    /* explicit for clarity; skip; rely on synthesized CNAME */
 708    break;
 709  default:
 710    /* unsupported type, skip it */
 711    break;
 712  }
 713  return DOH_OK;
 714}
 715
 716/* @unittest 1655 */
 717UNITTEST void de_init(struct dohentry *de);
 718UNITTEST void de_init(struct dohentry *de)
 719{
 720  int i;
 721  memset(de, 0, sizeof(*de));
 722  de->ttl = INT_MAX;
 723  for(i = 0; i < DOH_MAX_CNAME; i++)
 724    curlx_dyn_init(&de->cname[i], DYN_DOH_CNAME);
 725}
 726
 727/* @unittest 1655 */
 728UNITTEST DOHcode doh_resp_decode(const unsigned char *doh,
 729                                 size_t dohlen,
 730                                 DNStype dnstype,
 731                                 struct dohentry *d);
 732UNITTEST DOHcode doh_resp_decode(const unsigned char *doh,
 733                                 size_t dohlen,
 734                                 DNStype dnstype,
 735                                 struct dohentry *d)
 736{
 737  unsigned char rcode;
 738  unsigned short qdcount;
 739  unsigned short ancount;
 740  unsigned short type = 0;
 741  unsigned short rdlength;
 742  unsigned short nscount;
 743  unsigned short arcount;
 744  unsigned int index = 12;
 745  DOHcode rc;
 746
 747  if(dohlen < 12)
 748    return DOH_TOO_SMALL_BUFFER; /* too small */
 749  if(!doh || doh[0] || doh[1])
 750    return DOH_DNS_BAD_ID; /* bad ID */
 751  rcode = doh[3] & 0x0f;
 752  if(rcode)
 753    return DOH_DNS_BAD_RCODE; /* bad rcode */
 754
 755  qdcount = doh_get16bit(doh, 4);
 756  while(qdcount) {
 757    rc = doh_skipqname(doh, dohlen, &index);
 758    if(rc)
 759      return rc; /* bad qname */
 760    if(dohlen < (index + 4))
 761      return DOH_DNS_OUT_OF_RANGE;
 762    index += 4; /* skip question's type and class */
 763    qdcount--;
 764  }
 765
 766  ancount = doh_get16bit(doh, 6);
 767  while(ancount) {
 768    unsigned short dnsclass;
 769    unsigned int ttl;
 770
 771    rc = doh_skipqname(doh, dohlen, &index);
 772    if(rc)
 773      return rc; /* bad qname */
 774
 775    if(dohlen < (index + 2))
 776      return DOH_DNS_OUT_OF_RANGE;
 777
 778    type = doh_get16bit(doh, index);
 779    if((type != CURL_DNS_TYPE_CNAME) &&  /* may be synthesized from DNAME */
 780       (type != CURL_DNS_TYPE_DNAME) &&  /* if present, accept and ignore */
 781       (type != dnstype))
 782      /* Not the same type as was asked for nor CNAME nor DNAME */
 783      return DOH_DNS_UNEXPECTED_TYPE;
 784    index += 2;
 785
 786    if(dohlen < (index + 2))
 787      return DOH_DNS_OUT_OF_RANGE;
 788    dnsclass = doh_get16bit(doh, index);
 789    if(DNS_CLASS_IN != dnsclass)
 790      return DOH_DNS_UNEXPECTED_CLASS; /* unsupported */
 791    index += 2;
 792
 793    if(dohlen < (index + 4))
 794      return DOH_DNS_OUT_OF_RANGE;
 795
 796    ttl = doh_get32bit(doh, index);
 797    if(ttl < d->ttl)
 798      d->ttl = ttl;
 799    index += 4;
 800
 801    if(dohlen < (index + 2))
 802      return DOH_DNS_OUT_OF_RANGE;
 803
 804    rdlength = doh_get16bit(doh, index);
 805    index += 2;
 806    if(dohlen < (index + rdlength))
 807      return DOH_DNS_OUT_OF_RANGE;
 808
 809    rc = doh_rdata(doh, dohlen, rdlength, type, (int)index, d);
 810    if(rc)
 811      return rc; /* bad doh_rdata */
 812    index += rdlength;
 813    ancount--;
 814  }
 815
 816  nscount = doh_get16bit(doh, 8);
 817  while(nscount) {
 818    rc = doh_skipqname(doh, dohlen, &index);
 819    if(rc)
 820      return rc; /* bad qname */
 821
 822    if(dohlen < (index + 8))
 823      return DOH_DNS_OUT_OF_RANGE;
 824
 825    index += 2 + 2 + 4; /* type, dnsclass and ttl */
 826
 827    if(dohlen < (index + 2))
 828      return DOH_DNS_OUT_OF_RANGE;
 829
 830    rdlength = doh_get16bit(doh, index);
 831    index += 2;
 832    if(dohlen < (index + rdlength))
 833      return DOH_DNS_OUT_OF_RANGE;
 834    index += rdlength;
 835    nscount--;
 836  }
 837
 838  arcount = doh_get16bit(doh, 10);
 839  while(arcount) {
 840    rc = doh_skipqname(doh, dohlen, &index);
 841    if(rc)
 842      return rc; /* bad qname */
 843
 844    if(dohlen < (index + 8))
 845      return DOH_DNS_OUT_OF_RANGE;
 846
 847    index += 2 + 2 + 4; /* type, dnsclass and ttl */
 848
 849    if(dohlen < (index + 2))
 850      return DOH_DNS_OUT_OF_RANGE;
 851
 852    rdlength = doh_get16bit(doh, index);
 853    index += 2;
 854    if(dohlen < (index + rdlength))
 855      return DOH_DNS_OUT_OF_RANGE;
 856    index += rdlength;
 857    arcount--;
 858  }
 859
 860  if(index != dohlen)
 861    return DOH_DNS_MALFORMAT; /* something is wrong */
 862
 863#ifdef USE_HTTPSRR
 864  if((type != CURL_DNS_TYPE_NS) && !d->numcname && !d->numaddr &&
 865     !d->numhttps_rrs)
 866#else
 867  if((type != CURL_DNS_TYPE_NS) && !d->numcname && !d->numaddr)
 868#endif
 869    /* nothing stored! */
 870    return DOH_NO_CONTENT;
 871
 872  return DOH_OK; /* ok */
 873}
 874
 875#ifdef CURLVERBOSE
 876static void doh_show(struct Curl_easy *data,
 877                     const struct dohentry *d)
 878{
 879  int i;
 880  infof(data, "[DoH] TTL: %u seconds", d->ttl);
 881  for(i = 0; i < d->numaddr; i++) {
 882    const struct dohaddr *a = &d->addr[i];
 883    if(a->type == CURL_DNS_TYPE_A) {
 884      infof(data, "[DoH] A: %u.%u.%u.%u",
 885            a->ip.v4[0], a->ip.v4[1],
 886            a->ip.v4[2], a->ip.v4[3]);
 887    }
 888    else if(a->type == CURL_DNS_TYPE_AAAA) {
 889      int j;
 890      char buffer[128] = "[DoH] AAAA: ";
 891      size_t len = strlen(buffer);
 892      char *ptr = &buffer[len];
 893      len = sizeof(buffer) - len;
 894      for(j = 0; j < 16; j += 2) {
 895        size_t l;
 896        curl_msnprintf(ptr, len, "%s%02x%02x", j ? ":" : "",
 897                       d->addr[i].ip.v6[j],
 898                       d->addr[i].ip.v6[j + 1]);
 899        l = strlen(ptr);
 900        len -= l;
 901        ptr += l;
 902      }
 903      infof(data, "%s", buffer);
 904    }
 905  }
 906#ifdef USE_HTTPSRR
 907  for(i = 0; i < d->numhttps_rrs; i++) {
 908#if defined(DEBUGBUILD) && defined(CURLVERBOSE)
 909    doh_print_buf(data, "DoH HTTPS", d->https_rrs[i].val, d->https_rrs[i].len);
 910#else
 911    infof(data, "DoH HTTPS RR: length %d", d->https_rrs[i].len);
 912#endif
 913  }
 914#endif /* USE_HTTPSRR */
 915  for(i = 0; i < d->numcname; i++) {
 916    infof(data, "CNAME: %s", curlx_dyn_ptr(&d->cname[i]));
 917  }
 918}
 919#else
 920#define doh_show(x, y)
 921#endif
 922
 923/*
 924 * doh2ai()
 925 *
 926 * This function returns a pointer to the first element of a newly allocated
 927 * Curl_addrinfo struct linked list filled with the data from a set of DoH
 928 * lookups. Curl_addrinfo is meant to work like the addrinfo struct does for
 929 * an IPv6 stack, but usable also for IPv4, all hosts and environments.
 930 *
 931 * The memory allocated by this function *MUST* be free'd later on calling
 932 * Curl_freeaddrinfo(). For each successful call to this function there
 933 * must be an associated call later to Curl_freeaddrinfo().
 934 */
 935
 936static CURLcode doh2ai(const struct dohentry *de, const char *hostname,
 937                       int port, struct Curl_addrinfo **aip)
 938{
 939  struct Curl_addrinfo *ai;
 940  struct Curl_addrinfo *prevai = NULL;
 941  struct Curl_addrinfo *firstai = NULL;
 942  struct sockaddr_in *addr;
 943#ifdef USE_IPV6
 944  struct sockaddr_in6 *addr6;
 945#endif
 946  CURLcode result = CURLE_OK;
 947  int i;
 948  size_t hostlen = strlen(hostname) + 1; /* include null-terminator */
 949
 950  DEBUGASSERT(de);
 951
 952  if(!de->numaddr)
 953    return CURLE_COULDNT_RESOLVE_HOST;
 954
 955  for(i = 0; i < de->numaddr; i++) {
 956    size_t ss_size;
 957    CURL_SA_FAMILY_T addrtype;
 958    if(de->addr[i].type == CURL_DNS_TYPE_AAAA) {
 959#ifndef USE_IPV6
 960      /* we cannot handle IPv6 addresses */
 961      continue;
 962#else
 963      ss_size = sizeof(struct sockaddr_in6);
 964      addrtype = AF_INET6;
 965#endif
 966    }
 967    else {
 968      ss_size = sizeof(struct sockaddr_in);
 969      addrtype = AF_INET;
 970    }
 971
 972    ai = curlx_calloc(1, sizeof(struct Curl_addrinfo) + ss_size + hostlen);
 973    if(!ai) {
 974      result = CURLE_OUT_OF_MEMORY;
 975      break;
 976    }
 977    ai->ai_addr = (void *)((char *)ai + sizeof(struct Curl_addrinfo));
 978    ai->ai_canonname = (void *)((char *)ai->ai_addr + ss_size);
 979    memcpy(ai->ai_canonname, hostname, hostlen);
 980
 981    if(!firstai)
 982      /* store the pointer we want to return from this function */
 983      firstai = ai;
 984
 985    if(prevai)
 986      /* make the previous entry point to this */
 987      prevai->ai_next = ai;
 988
 989    ai->ai_family = addrtype;
 990
 991    /* we return all names as STREAM, so when using this address for TFTP
 992       the type must be ignored and conn->socktype be used instead! */
 993    ai->ai_socktype = SOCK_STREAM;
 994
 995    ai->ai_addrlen = (curl_socklen_t)ss_size;
 996
 997    /* leave the rest of the struct filled with zero */
 998
 999    switch(ai->ai_family) {
1000    case AF_INET:
1001      addr = (void *)ai->ai_addr; /* storage area for this info */
1002      DEBUGASSERT(sizeof(struct in_addr) == sizeof(de->addr[i].ip.v4));
1003      memcpy(&addr->sin_addr, &de->addr[i].ip.v4, sizeof(struct in_addr));
1004      addr->sin_family = addrtype;
1005      addr->sin_port = htons((unsigned short)port);
1006      break;
1007
1008#ifdef USE_IPV6
1009    case AF_INET6:
1010      addr6 = (void *)ai->ai_addr; /* storage area for this info */
1011      DEBUGASSERT(sizeof(struct in6_addr) == sizeof(de->addr[i].ip.v6));
1012      memcpy(&addr6->sin6_addr, &de->addr[i].ip.v6, sizeof(struct in6_addr));
1013      addr6->sin6_family = addrtype;
1014      addr6->sin6_port = htons((unsigned short)port);
1015      break;
1016#endif
1017    }
1018
1019    prevai = ai;
1020  }
1021
1022  if(result) {
1023    Curl_freeaddrinfo(firstai);
1024    firstai = NULL;
1025  }
1026  *aip = firstai;
1027
1028  return result;
1029}
1030
1031#ifdef CURLVERBOSE
1032static const char *doh_type2name(DNStype dnstype)
1033{
1034  switch(dnstype) {
1035  case CURL_DNS_TYPE_A:
1036    return "A";
1037  case CURL_DNS_TYPE_AAAA:
1038    return "AAAA";
1039#ifdef USE_HTTPSRR
1040  case CURL_DNS_TYPE_HTTPS:
1041    return "HTTPS";
1042#endif
1043  default:
1044    return "unknown";
1045  }
1046}
1047#endif
1048
1049/* @unittest 1655 */
1050UNITTEST void de_cleanup(struct dohentry *d);
1051UNITTEST void de_cleanup(struct dohentry *d)
1052{
1053  int i = 0;
1054  for(i = 0; i < d->numcname; i++) {
1055    curlx_dyn_free(&d->cname[i]);
1056  }
1057#ifdef USE_HTTPSRR
1058  for(i = 0; i < d->numhttps_rrs; i++)
1059    curlx_safefree(d->https_rrs[i].val);
1060#endif
1061}
1062
1063#ifdef USE_HTTPSRR
1064
1065/*
1066 * @brief decode the DNS name in a binary RRData
1067 * @param buf points to the buffer (in/out)
1068 * @param remaining points to the remaining buffer length (in/out)
1069 * @param dnsname returns the string form name on success
1070 * @return is 1 for success, error otherwise
1071 *
1072 * The encoding here is defined in
1073 * https://datatracker.ietf.org/doc/html/rfc1035#section-3.1
1074 *
1075 * The input buffer pointer will be modified so it points to after the end of
1076 * the DNS name encoding on output. (that is why it is an "unsigned char
1077 * **" :-)
1078 */
1079static CURLcode doh_decode_rdata_name(const unsigned char **buf,
1080                                      size_t *remaining, char **dnsname)
1081{
1082  const unsigned char *cp = NULL;
1083  size_t rem = 0;
1084  unsigned char clen = 0; /* chunk len */
1085  struct dynbuf thename;
1086
1087  DEBUGASSERT(buf && remaining && dnsname);
1088  if(!buf || !remaining || !dnsname || !*remaining)
1089    return CURLE_OUT_OF_MEMORY;
1090  curlx_dyn_init(&thename, CURL_MAXLEN_host_name);
1091  rem = *remaining;
1092  cp = *buf;
1093  clen = *cp++;
1094  if(clen == 0) {
1095    /* special case - return "." as name */
1096    if(curlx_dyn_addn(&thename, ".", 1))
1097      return CURLE_OUT_OF_MEMORY;
1098  }
1099  while(clen) {
1100    if(clen >= rem) {
1101      curlx_dyn_free(&thename);
1102      return CURLE_OUT_OF_MEMORY;
1103    }
1104    if(curlx_dyn_addn(&thename, cp, clen) ||
1105       curlx_dyn_addn(&thename, ".", 1))
1106      return CURLE_TOO_LARGE;
1107
1108    cp += clen;
1109    rem -= (clen + 1);
1110    if(rem <= 0) {
1111      curlx_dyn_free(&thename);
1112      return CURLE_OUT_OF_MEMORY;
1113    }
1114    clen = *cp++;
1115  }
1116  *buf = cp;
1117  *remaining = rem - 1;
1118  *dnsname = curlx_dyn_ptr(&thename);
1119  return CURLE_OK;
1120}
1121
1122/* @unittest 1658 */
1123UNITTEST CURLcode doh_resp_decode_httpsrr(struct Curl_easy *data,
1124                                          const unsigned char *cp, size_t len,
1125                                          struct Curl_https_rrinfo **hrr);
1126UNITTEST CURLcode doh_resp_decode_httpsrr(struct Curl_easy *data,
1127                                          const unsigned char *cp, size_t len,
1128                                          struct Curl_https_rrinfo **hrr)
1129{
1130  uint16_t pcode = 0, plen = 0;
1131  uint32_t expected_min_pcode = 0;
1132  struct Curl_https_rrinfo *lhrr = NULL;
1133  char *dnsname = NULL;
1134  CURLcode result = CURLE_OUT_OF_MEMORY;
1135  size_t olen;
1136
1137  (void)data;
1138  *hrr = NULL;
1139  if(len <= 2)
1140    return CURLE_BAD_FUNCTION_ARGUMENT;
1141  lhrr = curlx_calloc(1, sizeof(struct Curl_https_rrinfo));
1142  if(!lhrr)
1143    return CURLE_OUT_OF_MEMORY;
1144  lhrr->priority = doh_get16bit(cp, 0);
1145  cp += 2;
1146  len -= 2;
1147  if(doh_decode_rdata_name(&cp, &len, &dnsname) != CURLE_OK)
1148    goto err;
1149  lhrr->target = dnsname;
1150  if(Curl_junkscan(dnsname, &olen, FALSE)) {
1151    /* unacceptable hostname content */
1152    result = CURLE_WEIRD_SERVER_REPLY;
1153    goto err;
1154  }
1155  while(len >= 4) {
1156    pcode = doh_get16bit(cp, 0);
1157    plen = doh_get16bit(cp, 2);
1158    cp += 4;
1159    len -= 4;
1160    if(pcode < expected_min_pcode || plen > len) {
1161      result = CURLE_WEIRD_SERVER_REPLY;
1162      goto err;
1163    }
1164    result = Curl_httpsrr_set(lhrr, pcode, cp, plen);
1165    if(result)
1166      goto err;
1167    Curl_httpsrr_trace(data, lhrr);
1168    cp += plen;
1169    len -= plen;
1170    expected_min_pcode = pcode + 1;
1171  }
1172  DEBUGASSERT(!len);
1173  *hrr = lhrr;
1174  return CURLE_OK;
1175err:
1176  Curl_httpsrr_cleanup(lhrr);
1177  curlx_safefree(lhrr);
1178  return result;
1179}
1180
1181#if defined(DEBUGBUILD) && defined(CURLVERBOSE)
1182static void doh_print_httpsrr(struct Curl_easy *data,
1183                              struct Curl_https_rrinfo *hrr)
1184{
1185  DEBUGASSERT(hrr);
1186  infof(data, "HTTPS RR: priority %d, target: %s", hrr->priority, hrr->target);
1187  if(hrr->alpns[0] != ALPN_none)
1188    infof(data, "HTTPS RR: alpns %u %u %u %u",
1189          hrr->alpns[0], hrr->alpns[1], hrr->alpns[2], hrr->alpns[3]);
1190  else
1191    infof(data, "HTTPS RR: no alpns");
1192  if(hrr->no_def_alpn)
1193    infof(data, "HTTPS RR: no_def_alpn set");
1194  else
1195    infof(data, "HTTPS RR: no_def_alpn not set");
1196  if(hrr->ipv4hints) {
1197    doh_print_buf(data, "HTTPS RR: ipv4hints",
1198                  hrr->ipv4hints, hrr->ipv4hints_len);
1199  }
1200  else
1201    infof(data, "HTTPS RR: no ipv4hints");
1202  if(hrr->echconfiglist) {
1203    doh_print_buf(data, "HTTPS RR: ECHConfigList",
1204                  hrr->echconfiglist, hrr->echconfiglist_len);
1205  }
1206  else
1207    infof(data, "HTTPS RR: no ECHConfigList");
1208  if(hrr->ipv6hints) {
1209    doh_print_buf(data, "HTTPS RR: ipv6hint",
1210                  hrr->ipv6hints, hrr->ipv6hints_len);
1211  }
1212  else
1213    infof(data, "HTTPS RR: no ipv6hints");
1214}
1215# endif
1216#endif
1217
1218CURLcode Curl_doh_take_result(struct Curl_easy *data,
1219                              struct Curl_resolv_async *async,
1220                              struct Curl_dns_entry **pdns)
1221{
1222  struct doh_probes *dohp = async->doh;
1223  CURLcode result = CURLE_OK;
1224  struct dohentry de;
1225
1226  *pdns = NULL; /* defaults to no response */
1227  if(!dohp)
1228    return CURLE_OUT_OF_MEMORY;
1229
1230  if(dohp->probe_resp[DOH_SLOT_IPV4].probe_mid == UINT32_MAX &&
1231     dohp->probe_resp[DOH_SLOT_IPV6].probe_mid == UINT32_MAX) {
1232    failf(data, "Could not DoH-resolve: %s", dohp->host);
1233    return async->for_proxy ?
1234      CURLE_COULDNT_RESOLVE_PROXY : CURLE_COULDNT_RESOLVE_HOST;
1235  }
1236  else if(!dohp->pending) {
1237    DOHcode rc[DOH_SLOT_COUNT];
1238    int slot;
1239
1240    memset(rc, 0, sizeof(rc));
1241    /* remove DoH handles from multi handle and close them */
1242    doh_close(data, async);
1243    /* parse the responses, create the struct and return it! */
1244    de_init(&de);
1245    for(slot = 0; slot < DOH_SLOT_COUNT; slot++) {
1246      struct doh_response *p = &dohp->probe_resp[slot];
1247      if(!p->dnstype)
1248        continue;
1249      rc[slot] = doh_resp_decode(curlx_dyn_uptr(&p->body),
1250                                 curlx_dyn_len(&p->body),
1251                                 p->dnstype, &de);
1252      if(rc[slot]) {
1253        CURL_TRC_DNS(data, "DoH: %s type %s for %s", doh_strerror(rc[slot]),
1254                     doh_type2name(p->dnstype), dohp->host);
1255      }
1256    } /* next slot */
1257
1258    if(!rc[DOH_SLOT_IPV4] || !rc[DOH_SLOT_IPV6]) {
1259      /* we have an address, of one kind or other */
1260      struct Curl_dns_entry *dns;
1261      struct Curl_addrinfo *ai;
1262
1263      if(Curl_trc_ft_is_verbose(data, &Curl_trc_feat_dns)) {
1264        CURL_TRC_DNS(data, "hostname: %s", dohp->host);
1265        doh_show(data, &de);
1266      }
1267
1268      result = doh2ai(&de, dohp->host, dohp->port, &ai);
1269      if(result)
1270        goto error;
1271
1272      /* we got a response, create a dns entry. */
1273      dns = Curl_dnscache_mk_entry(data, async->dns_queries,
1274                                   &ai, dohp->host, dohp->port);
1275      if(!dns) {
1276        result = CURLE_OUT_OF_MEMORY;
1277        goto error;
1278      }
1279
1280      /* Now add and HTTPSRR information if we have */
1281#ifdef USE_HTTPSRR
1282      if(de.numhttps_rrs > 0 && result == CURLE_OK) {
1283        struct Curl_https_rrinfo *hrr = NULL;
1284        result = doh_resp_decode_httpsrr(data, de.https_rrs->val,
1285                                         de.https_rrs->len, &hrr);
1286        if(result) {
1287          infof(data, "Failed to decode HTTPS RR");
1288          Curl_dns_entry_unlink(data, &dns);
1289          goto error;
1290        }
1291        infof(data, "Some HTTPS RR to process");
1292#if defined(DEBUGBUILD) && defined(CURLVERBOSE)
1293        doh_print_httpsrr(data, hrr);
1294#endif
1295        Curl_dns_entry_set_https_rr(dns, hrr);
1296      }
1297#endif /* USE_HTTPSRR */
1298
1299      /* and add the entry to the cache */
1300      result = Curl_dnscache_add(data, dns);
1301      *pdns = dns;
1302    } /* address processing done */
1303    else {
1304      result = async->for_proxy ?
1305        CURLE_COULDNT_RESOLVE_PROXY : CURLE_COULDNT_RESOLVE_HOST;
1306    }
1307
1308  } /* !dohp->pending */
1309  else
1310    /* wait for pending DoH transactions to complete */
1311    return CURLE_AGAIN;
1312
1313error:
1314  de_cleanup(&de);
1315  Curl_doh_cleanup(data, async);
1316  return result;
1317}
1318
1319static void doh_close(struct Curl_easy *data,
1320                      struct Curl_resolv_async *async)
1321{
1322  struct doh_probes *doh = async ? async->doh : NULL;
1323  if(doh && data->multi) {
1324    struct Curl_easy *probe_data;
1325    uint32_t mid;
1326    size_t slot;
1327    for(slot = 0; slot < DOH_SLOT_COUNT; slot++) {
1328      mid = doh->probe_resp[slot].probe_mid;
1329      if(mid == UINT32_MAX)
1330        continue;
1331      doh->probe_resp[slot].probe_mid = UINT32_MAX;
1332      /* should have been called before data is removed from multi handle */
1333      DEBUGASSERT(data->multi);
1334      probe_data = data->multi ? Curl_multi_get_easy(data->multi, mid) : NULL;
1335      if(!probe_data) {
1336        DEBUGF(infof(data, "Curl_doh_close: xfer for mid=%u not found!",
1337                     doh->probe_resp[slot].probe_mid));
1338        continue;
1339      }
1340      /* data->multi might already be reset at this time */
1341      curl_multi_remove_handle(data->multi, probe_data);
1342      Curl_close(&probe_data);
1343    }
1344    data->sub_xfer_done = NULL;
1345  }
1346}
1347
1348void Curl_doh_cleanup(struct Curl_easy *data,
1349                      struct Curl_resolv_async *async)
1350{
1351  struct doh_probes *dohp = async->doh;
1352  if(dohp) {
1353    int i;
1354    doh_close(data, async);
1355    for(i = 0; i < DOH_SLOT_COUNT; ++i) {
1356      curlx_dyn_free(&dohp->probe_resp[i].body);
1357    }
1358    curlx_safefree(async->doh);
1359  }
1360}
1361
1362#endif /* CURL_DISABLE_DOH */