resolver_getaddrinfo_shim.cc

Go to the documentation of this file.

/*
 * Copyright (C) Max Dymond, <cmeister2@gmail.com>, et al.
 *
 * SPDX-License-Identifier: curl
 */

 
#include <arpa/inet.h>
#include <netdb.h>
#include <netinet/in.h>
#include <sys/socket.h>
 
#include <cerrno>
#include <chrono>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <thread>
 
#include "proto_fuzzer/resolver_cancel_gate.h"
 
namespace {
 
constexpr char kPositiveHost[] = "resolver-positive.test";
constexpr char kPartialHost[] = "resolver-partial.test";
constexpr char kNegativeHost[] = "resolver-negative.test";
constexpr char kLinkLocalHost[] = "resolver-link-local.test";
constexpr char kQueuedCancelHost[] = "resolver-queued-cancel.test";
 
unsigned short ParsePort(const char* service) {
  if (service == nullptr || *service == '\0') {
    return 0;
  }
  char* end = nullptr;
  errno = 0;
  const unsigned long value = std::strtoul(service, &end, 10);
  if (errno != 0 || end == service || *end != '\0' || value > UINT16_MAX) {
    return 0;
  }
  return static_cast<unsigned short>(value);
}
 
addrinfo* AllocateAddress(int family, const addrinfo* hints, unsigned short port, const void* address) {
  auto* node = static_cast<addrinfo*>(std::calloc(1, sizeof(addrinfo)));
  if (node == nullptr) {
    return nullptr;
  }
 
  const std::size_t address_size = family == AF_INET ? sizeof(sockaddr_in) : sizeof(sockaddr_in6);
  auto* socket_address = static_cast<sockaddr*>(std::calloc(1, address_size));
  if (socket_address == nullptr) {
    std::free(node);
    return nullptr;
  }
 
  node->ai_flags = hints == nullptr ? 0 : hints->ai_flags;
  node->ai_family = family;
  node->ai_socktype = hints == nullptr || hints->ai_socktype == 0 ? SOCK_STREAM : hints->ai_socktype;
  node->ai_protocol = hints == nullptr ? 0 : hints->ai_protocol;
  node->ai_addrlen = static_cast<socklen_t>(address_size);
  node->ai_addr = socket_address;
 
  if (family == AF_INET) {
    auto* ipv4 = reinterpret_cast<sockaddr_in*>(socket_address);
    ipv4->sin_family = AF_INET;
    ipv4->sin_port = htons(port);
    std::memcpy(&ipv4->sin_addr, address, sizeof(ipv4->sin_addr));
  } else {
    auto* ipv6 = reinterpret_cast<sockaddr_in6*>(socket_address);
    ipv6->sin6_family = AF_INET6;
    ipv6->sin6_port = htons(port);
    std::memcpy(&ipv6->sin6_addr, address, sizeof(ipv6->sin6_addr));
  }
  return node;
}
 
bool AppendAddress(addrinfo** head, addrinfo** tail, int family, const addrinfo* hints, unsigned short port,
                   const char* address) {
  in_addr ipv4{};
  in6_addr ipv6{};
  const void* bytes = nullptr;
  if (family == AF_INET) {
    if (inet_pton(AF_INET, address, &ipv4) != 1) {
      return false;
    }
    bytes = &ipv4;
  } else {
    if (inet_pton(AF_INET6, address, &ipv6) != 1) {
      return false;
    }
    bytes = &ipv6;
  }
 
  addrinfo* node = AllocateAddress(family, hints, port, bytes);
  if (node == nullptr) {
    return false;
  }
  if (*tail == nullptr) {
    *head = node;
  } else {
    (*tail)->ai_next = node;
  }
  *tail = node;
  return true;
}
 
void FreeAddressList(addrinfo* address) noexcept {
  while (address != nullptr) {
    addrinfo* next = address->ai_next;
    std::free(address->ai_addr);
    std::free(address->ai_canonname);
    std::free(address);
    address = next;
  }
}
 
}  // namespace

extern "C" int getaddrinfo(const char* nodename, const char* service, const addrinfo* hints, addrinfo** result) {
  if (result == nullptr) {
    return EAI_FAIL;
  }
  *result = nullptr;
  if (nodename == nullptr) {
    return EAI_NONAME;
  }
 
  const bool negative = std::strcmp(nodename, kNegativeHost) == 0;
 
  const bool positive = std::strcmp(nodename, kPositiveHost) == 0;
  const bool partial = std::strcmp(nodename, kPartialHost) == 0;
  const bool link_local = std::strcmp(nodename, kLinkLocalHost) == 0;
  const bool queued_cancel = std::strcmp(nodename, kQueuedCancelHost) == 0;
  if (!positive && !negative && !partial && !link_local && !queued_cancel) {
    return EAI_NONAME;
  }
 
  // This hostname is selected only by the queued-cancellation resolver mode.
  // The main thread waits until the first handle's first family is stopped
  // here, then adds and starts a duplicate handle. With the public resolver
  // pool capped at one worker, no later family can be dequeued before the
  // duplicate's pending resolver work is cancelled.
  if (queued_cancel) {
    proto_fuzzer::WaitAtResolverCancelGate();
  }
 
  // Hold every owned answer for one bounded interval so curl's first public
  // poll observes live resolver work. Unlike a scheduler race or debug-only
  // environment hook, this is part of the target-local backend contract.
  std::this_thread::sleep_for(std::chrono::milliseconds(1));
  if (negative) {
    return EAI_NONAME;
  }
 
  const int family = hints == nullptr ? AF_UNSPEC : hints->ai_family;
  if (family != AF_UNSPEC && family != AF_INET && family != AF_INET6) {
    return EAI_FAMILY;
  }
 
  const unsigned short port = ParsePort(service);
  if (partial && family == AF_INET) {
    // Keep the A answer behind the AAAA answer by a small, fixed interval.
    // curl can then consume the first asynchronous family through its live
    // resolver accessor before the complete result moves into the DNS cache.
    std::this_thread::sleep_for(std::chrono::milliseconds(4));
  }
  addrinfo* head = nullptr;
  addrinfo* tail = nullptr;
  bool ok = true;
  if (positive || partial || queued_cancel) {
    if (family == AF_UNSPEC || family == AF_INET6) {
      ok = AppendAddress(&head, &tail, AF_INET6, hints, port, "::1") &&
           AppendAddress(&head, &tail, AF_INET6, hints, port, "::2");
    }
    if (ok && (family == AF_UNSPEC || family == AF_INET)) {
      ok = AppendAddress(&head, &tail, AF_INET, hints, port, "127.0.0.1") &&
           AppendAddress(&head, &tail, AF_INET, hints, port, "127.0.0.2");
    }
  } else if (family == AF_INET6) {
    ok = AppendAddress(&head, &tail, AF_INET6, hints, port, "fe80::1");
  } else if (family == AF_UNSPEC) {
    ok = AppendAddress(&head, &tail, AF_INET6, hints, port, "fe80::1") &&
         AppendAddress(&head, &tail, AF_INET, hints, port, "127.0.0.1");
  } else {
    ok = AppendAddress(&head, &tail, AF_INET, hints, port, "127.0.0.1");
  }
 
  if (!ok || head == nullptr) {
    FreeAddressList(head);
    return EAI_MEMORY;
  }
  *result = head;
  return 0;
}

extern "C" void freeaddrinfo(addrinfo* address) noexcept { FreeAddressList(address); }