lib/net/resolve.c

/* Copyright (c) 2003-2004, Roger Dingledine
 * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
 * Copyright (c) 2007-2021, The Tor Project, Inc. */
/* See LICENSE for licensing information */

/**
 * \file resolve.c
 * \brief Use the libc DNS resolver to convert hostnames into addresses.
 **/

#define RESOLVE_PRIVATE
#include "lib/net/resolve.h"

#include "lib/net/address.h"
#include "lib/net/inaddr.h"
#include "lib/malloc/malloc.h"
#include "lib/string/parse_int.h"
#include "lib/string/util_string.h"

#include "ext/siphash.h"
#include "ext/ht.h"

#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#ifdef HAVE_NETDB_H
#include <netdb.h>
#endif

#include <string.h>

/** Similar behavior to Unix gethostbyname: resolve <b>name</b>, and set
 * *<b>addr</b> to the proper IP address, in host byte order.  Returns 0
 * on success, -1 on failure; 1 on transient failure.
 *
 * This function only accepts IPv4 addresses.
 *
 * (This function exists because standard windows gethostbyname
 * doesn't treat raw IP addresses properly.)
 */

MOCK_IMPL(int,
tor_lookup_hostname,(const char *name, uint32_t *addr))
{
  tor_addr_t myaddr;
  int ret;

  if (BUG(!addr))
    return -1;

  *addr = 0;

  if ((ret = tor_addr_lookup(name, AF_INET, &myaddr)))
    return ret;

  if (tor_addr_family(&myaddr) == AF_INET) {
    *addr = tor_addr_to_ipv4h(&myaddr);
    return ret;
  }

  return -1;
}

#ifdef HAVE_GETADDRINFO

/* Host lookup helper for tor_addr_lookup(), when getaddrinfo() is
 * available on this system.
 *
 * See tor_addr_lookup() for details.
 */
MOCK_IMPL(STATIC int,
tor_addr_lookup_host_impl,(const char *name,
                          uint16_t family,
                          tor_addr_t *addr))
{
  int err;
  struct addrinfo *res=NULL, *res_p;
  struct addrinfo *best=NULL;
  struct addrinfo hints;
  int result = -1;
  memset(&hints, 0, sizeof(hints));
  hints.ai_family = family;
  hints.ai_socktype = SOCK_STREAM;
  err = tor_getaddrinfo(name, NULL, &hints, &res);
  /* The check for 'res' here shouldn't be necessary, but it makes static
   * analysis tools happy. */
  if (!err && res) {
    best = NULL;
    for (res_p = res; res_p; res_p = res_p->ai_next) {
      if (family == AF_UNSPEC) {
        if (res_p->ai_family == AF_INET) {
          best = res_p;
          break;
        } else if (res_p->ai_family == AF_INET6 && !best) {
          best = res_p;
        }
      } else if (family == res_p->ai_family) {
        best = res_p;
        break;
      }
    }
    if (!best)
      best = res;
    if (best->ai_family == AF_INET) {
      tor_addr_from_in(addr,
                       &((struct sockaddr_in*)best->ai_addr)->sin_addr);
      result = 0;
    } else if (best->ai_family == AF_INET6) {
      tor_addr_from_in6(addr,
                        &((struct sockaddr_in6*)best->ai_addr)->sin6_addr);
      result = 0;
    }
    tor_freeaddrinfo(res);
    return result;
  }
  return (err == EAI_AGAIN) ? 1 : -1;
}

#else /* !defined(HAVE_GETADDRINFO) */

/* Host lookup helper for tor_addr_lookup(), which calls gethostbyname().
 * Used when getaddrinfo() is not available on this system.
 *
 * See tor_addr_lookup() for details.
 */
MOCK_IMPL(STATIC int,
tor_addr_lookup_host_impl,(const char *name,
                          uint16_t family,
                           tor_addr_t *addr))
{
  (void) family;
  struct hostent *ent;
  int err;
#ifdef HAVE_GETHOSTBYNAME_R_6_ARG
  char buf[2048];
  struct hostent hostent;
  int r;
  r = gethostbyname_r(name, &hostent, buf, sizeof(buf), &ent, &err);
#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
  char buf[2048];
  struct hostent hostent;
  ent = gethostbyname_r(name, &hostent, buf, sizeof(buf), &err);
#elif defined(HAVE_GETHOSTBYNAME_R_3_ARG)
  struct hostent_data data;
  struct hostent hent;
  memset(&data, 0, sizeof(data));
  err = gethostbyname_r(name, &hent, &data);
  ent = err ? NULL : &hent;
#else
  ent = gethostbyname(name);
#ifdef _WIN32
  err = WSAGetLastError();
#else
  err = h_errno;
#endif /* defined(_WIN32) */
#endif /* defined(HAVE_GETHOSTBYNAME_R_6_ARG) || ... */
  if (ent) {
    if (ent->h_addrtype == AF_INET) {
      tor_addr_from_in(addr, (struct in_addr*) ent->h_addr);
    } else if (ent->h_addrtype == AF_INET6) {
      tor_addr_from_in6(addr, (struct in6_addr*) ent->h_addr);
    } else {
      tor_assert(0); // LCOV_EXCL_LINE: gethostbyname() returned bizarre type
    }
    return 0;
  }
#ifdef _WIN32
  return (err == WSATRY_AGAIN) ? 1 : -1;
#else
  return (err == TRY_AGAIN) ? 1 : -1;
#endif
}
#endif /* defined(HAVE_GETADDRINFO) */

/** Similar behavior to Unix gethostbyname: resolve <b>name</b>, and set
 * *<b>addr</b> to the proper IP address and family. The <b>family</b>
 * argument (which must be AF_INET, AF_INET6, or AF_UNSPEC) declares a
 * <i>preferred</i> family, though another one may be returned if only one
 * family is implemented for this address.
 *
 * Like tor_addr_parse(), this function accepts IPv6 addresses with or without
 * square brackets.
 *
 * Return 0 on success, -1 on failure; 1 on transient failure.
 */
MOCK_IMPL(int,
tor_addr_lookup,(const char *name, uint16_t family, tor_addr_t *addr))
{
  /* Perhaps eventually this should be replaced by a tor_getaddrinfo or
   * something.
   */
  int parsed_family = 0;
  int result = -1;

  tor_assert(name);
  tor_assert(addr);
  tor_assert(family == AF_INET || family == AF_INET6 || family == AF_UNSPEC);

  if (!*name) {
    /* Empty address is an error. */
    goto permfail;
  }

  /* Is it an IP address? */
  parsed_family = tor_addr_parse(addr, name);

  if (parsed_family >= 0) {
    /* If the IP address family matches, or was unspecified */
    if (parsed_family == family || family == AF_UNSPEC) {
      goto success;
    } else {
      goto permfail;
    }
  } else {
    /* Clear the address after a failed tor_addr_parse(). */
    memset(addr, 0, sizeof(tor_addr_t));
    result = tor_addr_lookup_host_impl(name, family, addr);
    goto done;
  }

 /* If we weren't successful, and haven't already set the result,
  * assume it's a permanent failure */
 permfail:
  result = -1;
  goto done;
 success:
  result = 0;

 /* We have set the result, now it's time to clean up */
 done:
  if (result) {
    /* Clear the address on error */
    memset(addr, 0, sizeof(tor_addr_t));
  }
  return result;
}

/** Parse an address or address-port combination from <b>s</b>, resolve the
 * address as needed, and put the result in <b>addr_out</b> and (optionally)
 * <b>port_out</b>.
 *
 * Like tor_addr_port_parse(), this function accepts:
 *  - IPv6 address and port, when the IPv6 address is in square brackets,
 *  - IPv6 address with square brackets,
 *  - IPv6 address without square brackets.
 *
 * Return 0 on success, negative on failure. */
int
tor_addr_port_lookup(const char *s, tor_addr_t *addr_out, uint16_t *port_out)
{
  tor_addr_t addr;
  uint16_t portval = 0;
  char *tmp = NULL;
  int rv = 0;
  int result;

  tor_assert(s);
  tor_assert(addr_out);

  s = eat_whitespace(s);

  /* Try parsing s as an address:port first, so we don't have to duplicate
   * the logic that rejects IPv6:Port with no square brackets. */
  rv = tor_addr_port_parse(LOG_WARN, s, &addr, &portval, 0);
  /* That was easy, no DNS required. */
  if (rv == 0)
    goto success;

  /* Now let's check for malformed IPv6 addresses and ports:
   * tor_addr_port_parse() requires squared brackes if there is a port,
   * and we want tor_addr_port_lookup() to have the same requirement.
   * But we strip the port using tor_addr_port_split(), so tor_addr_lookup()
   * only sees the address, and will accept it without square brackets. */
  int family = tor_addr_parse(&addr, s);
  /* If tor_addr_parse() succeeds where tor_addr_port_parse() failed, we need
   * to reject this address as malformed. */
  if (family >= 0) {
    /* Double-check it's an IPv6 address. If not, we have a parsing bug.
     */
    tor_assertf_nonfatal(family == AF_INET6,
                         "Wrong family: %d (should be IPv6: %d) which "
                         "failed IP:port parsing, but passed IP parsing. "
                         "input string: '%s'; parsed address: '%s'.",
                         family, AF_INET6, s, fmt_addr(&addr));
    goto err;
  }

  /* Now we have a hostname. Let's split off the port, if any. */
  rv = tor_addr_port_split(LOG_WARN, s, &tmp, &portval);
  if (rv < 0)
    goto err;

  /* And feed the hostname to the lookup function. */
  if (tor_addr_lookup(tmp, AF_UNSPEC, &addr) != 0)
    goto err;

 success:
  if (port_out)
    *port_out = portval;
  tor_addr_copy(addr_out, &addr);
  result = 0;
  goto done;

 err:
  /* Clear the address and port on error */
  memset(addr_out, 0, sizeof(tor_addr_t));
  if (port_out)
    *port_out = 0;
  result = -1;

 /* We have set the result, now it's time to clean up */
 done:
  tor_free(tmp);
  return result;
}

#ifdef USE_SANDBOX_GETADDRINFO
/** True if we should only return cached values */
static int sandbox_getaddrinfo_is_active = 0;

/** Cache entry for getaddrinfo results; used when sandboxing is implemented
 * so that we can consult the cache when the sandbox prevents us from doing
 * getaddrinfo.
 *
 * We support only a limited range of getaddrinfo calls, where servname is null
 * and hints contains only socktype=SOCK_STREAM, family in INET,INET6,UNSPEC.
 */
typedef struct cached_getaddrinfo_item_t {
  HT_ENTRY(cached_getaddrinfo_item_t) node;
  char *name;
  int family;
  /** set if no error; otherwise NULL */
  struct addrinfo *res;
  /** 0 for no error; otherwise an EAI_* value */
  int err;
} cached_getaddrinfo_item_t;

static unsigned
cached_getaddrinfo_item_hash(const cached_getaddrinfo_item_t *item)
{
  return (unsigned)siphash24g(item->name, strlen(item->name)) + item->family;
}

static unsigned
cached_getaddrinfo_items_eq(const cached_getaddrinfo_item_t *a,
                            const cached_getaddrinfo_item_t *b)
{
  return (a->family == b->family) && 0 == strcmp(a->name, b->name);
}

#define cached_getaddrinfo_item_free(item)              \
  FREE_AND_NULL(cached_getaddrinfo_item_t,              \
                cached_getaddrinfo_item_free_, (item))

static void
cached_getaddrinfo_item_free_(cached_getaddrinfo_item_t *item)
{
  if (item == NULL)
    return;

  tor_free(item->name);
  if (item->res)
    freeaddrinfo(item->res);
  tor_free(item);
}

static HT_HEAD(getaddrinfo_cache, cached_getaddrinfo_item_t)
     getaddrinfo_cache = HT_INITIALIZER();

HT_PROTOTYPE(getaddrinfo_cache, cached_getaddrinfo_item_t, node,
             cached_getaddrinfo_item_hash,
             cached_getaddrinfo_items_eq);
HT_GENERATE2(getaddrinfo_cache, cached_getaddrinfo_item_t, node,
             cached_getaddrinfo_item_hash,
             cached_getaddrinfo_items_eq,
             0.6, tor_reallocarray_, tor_free_);

/** If true, don't try to cache getaddrinfo results. */
static int sandbox_getaddrinfo_cache_disabled = 0;

/** Tell the sandbox layer not to try to cache getaddrinfo results. Used as in
 * tor-resolve, when we have no intention of initializing crypto or of
 * installing the sandbox.*/
void
sandbox_disable_getaddrinfo_cache(void)
{
  sandbox_getaddrinfo_cache_disabled = 1;
}

void
tor_freeaddrinfo(struct addrinfo *ai)
{
  if (sandbox_getaddrinfo_cache_disabled)
    freeaddrinfo(ai);
}

int
tor_getaddrinfo(const char *name, const char *servname,
                const struct addrinfo *hints,
                struct addrinfo **res)
{
  int err;
  struct cached_getaddrinfo_item_t search, *item;

  if (sandbox_getaddrinfo_cache_disabled) {
    return getaddrinfo(name, NULL, hints, res);
  }

  if (servname != NULL) {
    log_warn(LD_BUG, "called with non-NULL servname");
    return EAI_NONAME;
  }
  if (name == NULL) {
    log_warn(LD_BUG, "called with NULL name");
    return EAI_NONAME;
  }

  *res = NULL;

  memset(&search, 0, sizeof(search));
  search.name = (char *) name;
  search.family = hints ? hints->ai_family : AF_UNSPEC;
  item = HT_FIND(getaddrinfo_cache, &getaddrinfo_cache, &search);

  if (! sandbox_getaddrinfo_is_active) {
    /* If the sandbox is not turned on yet, then getaddrinfo and store the
       result. */

    err = getaddrinfo(name, NULL, hints, res);
    log_info(LD_NET,"(Sandbox) getaddrinfo %s.", err ? "failed" : "succeeded");

    if (! item) {
      item = tor_malloc_zero(sizeof(*item));
      item->name = tor_strdup(name);
      item->family = hints ? hints->ai_family : AF_UNSPEC;
      HT_INSERT(getaddrinfo_cache, &getaddrinfo_cache, item);
    }

    if (item->res) {
      freeaddrinfo(item->res);
      item->res = NULL;
    }
    item->res = *res;
    item->err = err;
    return err;
  }

  /* Otherwise, the sandbox is on.  If we have an item, yield its cached
     result. */
  if (item) {
    *res = item->res;
    return item->err;
  }

  /* getting here means something went wrong */
  log_err(LD_BUG,"(Sandbox) failed to get address %s!", name);
  return EAI_NONAME;
}

int
tor_add_addrinfo(const char *name)
{
  struct addrinfo *res;
  struct addrinfo hints;
  int i;
  static const int families[] = { AF_INET, AF_INET6, AF_UNSPEC };

  memset(&hints, 0, sizeof(hints));
  hints.ai_socktype = SOCK_STREAM;
  for (i = 0; i < 3; ++i) {
    hints.ai_family = families[i];

    res = NULL;
    (void) tor_getaddrinfo(name, NULL, &hints, &res);
    if (res)
      tor_freeaddrinfo(res);
  }

  return 0;
}

void
tor_free_getaddrinfo_cache(void)
{
  cached_getaddrinfo_item_t **next, **item, *this;

  for (item = HT_START(getaddrinfo_cache, &getaddrinfo_cache);
       item;
       item = next) {
    this = *item;
    next = HT_NEXT_RMV(getaddrinfo_cache, &getaddrinfo_cache, item);
    cached_getaddrinfo_item_free(this);
  }

  HT_CLEAR(getaddrinfo_cache, &getaddrinfo_cache);
}

void
tor_make_getaddrinfo_cache_active(void)
{
  sandbox_getaddrinfo_is_active = 1;
}
#else /* !defined(USE_SANDBOX_GETADDRINFO) */
void
sandbox_disable_getaddrinfo_cache(void)
{
}
void
tor_make_getaddrinfo_cache_active(void)
{
}
#endif /* defined(USE_SANDBOX_GETADDRINFO) */