glib/gio/gthreadedresolver.c

/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */

/* GIO - GLib Input, Output and Streaming Library
 *
 * Copyright (C) 2008 Red Hat, Inc.
 * Copyright (C) 2018 Igalia S.L.
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General
 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
 */

#include "config.h"
#include <glib.h>
#include "glibintl.h"

#include <stdio.h>
#include <string.h>

#include "glib/glib-private.h"
#include "gthreadedresolver.h"
#include "gthreadedresolver-private.h"
#include "gnetworkingprivate.h"

#include "gcancellable.h"
#include "ginetaddress.h"
#include "ginetsocketaddress.h"
#include "gtask.h"
#include "gsocketaddress.h"
#include "gsrvtarget.h"

/*
 * GThreadedResolver is a threaded wrapper around the system libc’s
 * `getaddrinfo()`.
 *
 * It has to be threaded, as `getaddrinfo()` is synchronous. libc does provide
 * `getaddrinfo_a()` as an asynchronous version of `getaddrinfo()`, but it does
 * not integrate with a poll loop. It requires use of sigevent to notify of
 * completion of an asynchronous operation. That either emits a signal, or calls
 * a callback function in a newly spawned thread.
 *
 * A signal (`SIGEV_SIGNAL`) can’t be used for completion as (aside from being
 * another expensive round trip into the kernel) GLib cannot pick a `SIG*`
 * number which is guaranteed to not be in use elsewhere in the process. Various
 * other things could be interfering with signal dispositions, such as gdb or
 * other libraries in the process. Using a `signalfd()`
 * [cannot improve this situation](https://ldpreload.com/blog/signalfd-is-useless).
 *
 * A callback function in a newly spawned thread (`SIGEV_THREAD`) could be used,
 * but that is very expensive. Internally, glibc currently also just implements
 * `getaddrinfo_a()`
 * [using its own thread pool](https://github.com/bminor/glibc/blob/master/resolv/gai_misc.c),
 * and then
 * [spawns an additional thread for each completion callback](https://github.com/bminor/glibc/blob/master/resolv/gai_notify.c).
 * That is very expensive.
 *
 * No other appropriate sigevent callback types
 * [currently exist](https://sourceware.org/bugzilla/show_bug.cgi?id=30287), and
 * [others agree that sigevent is not great](http://davmac.org/davpage/linux/async-io.html#posixaio).
 *
 * Hence, #GThreadedResolver calls the normal synchronous `getaddrinfo()` in its
 * own thread pool. Previously, #GThreadedResolver used the thread pool which is
 * internal to #GTask by calling g_task_run_in_thread(). That lead to exhaustion
 * of the #GTask thread pool in some situations, though, as DNS lookups are
 * quite frequent leaf operations in some use cases. Now, #GThreadedResolver
 * uses its own private thread pool.
 *
 * This is similar to what
 * [libasyncns](http://git.0pointer.net/libasyncns.git/tree/libasyncns/asyncns.h)
 * and other multi-threaded users of `getaddrinfo()` do.
 */

struct _GThreadedResolver
{
  GResolver parent_instance;

  GThreadPool *thread_pool;  /* (owned) */
};

G_DEFINE_TYPE (GThreadedResolver, g_threaded_resolver, G_TYPE_RESOLVER)

static void run_task_in_thread_pool_async (GThreadedResolver *self,
                                           GTask             *task);
static void run_task_in_thread_pool_sync (GThreadedResolver *self,
                                          GTask             *task);
static void threaded_resolver_worker_cb (gpointer task_data,
                                         gpointer user_data);

static void
g_threaded_resolver_init (GThreadedResolver *self)
{
  self->thread_pool = g_thread_pool_new_full (threaded_resolver_worker_cb,
                                              self,
                                              (GDestroyNotify) g_object_unref,
                                              20,
                                              FALSE,
                                              NULL);
}

static void
g_threaded_resolver_finalize (GObject *object)
{
  GThreadedResolver *self = G_THREADED_RESOLVER (object);

  g_thread_pool_free (self->thread_pool, TRUE, FALSE);
  self->thread_pool = NULL;

  G_OBJECT_CLASS (g_threaded_resolver_parent_class)->finalize (object);
}

static GResolverError
g_resolver_error_from_addrinfo_error (gint err)
{
  switch (err)
    {
    case EAI_FAIL:
#if defined(EAI_NODATA) && (EAI_NODATA != EAI_NONAME)
    case EAI_NODATA:
#endif
    case EAI_NONAME:
      return G_RESOLVER_ERROR_NOT_FOUND;

    case EAI_AGAIN:
      return G_RESOLVER_ERROR_TEMPORARY_FAILURE;

    default:
      return G_RESOLVER_ERROR_INTERNAL;
    }
}

typedef struct {
  enum {
    LOOKUP_BY_NAME,
    LOOKUP_BY_ADDRESS,
    LOOKUP_RECORDS,
  } lookup_type;

  union {
    struct {
      char *hostname;
      int address_family;
    } lookup_by_name;
    struct {
      GInetAddress *address;  /* (owned) */
    } lookup_by_address;
    struct {
      char *rrname;
      GResolverRecordType record_type;
    } lookup_records;
  };

  GCond cond;  /* used for signalling completion of the task when running it sync */
  GMutex lock;

  GSource *timeout_source;  /* (nullable) (owned) */
  GSource *cancellable_source;  /* (nullable) (owned) */

  /* This enum indicates that a particular code path has claimed the
   * task and is shortly about to call g_task_return_*() on it.
   * This must be accessed with GThreadedResolver.lock held. */
  enum
    {
      NOT_YET,
      COMPLETED,  /* libc lookup call has completed successfully or errored */
      TIMED_OUT,
      CANCELLED,
    } will_return;

  /* Whether the thread pool thread executing this lookup has finished executing
   * it and g_task_return_*() has been called on it already.
   * This must be accessed with GThreadedResolver.lock held. */
  gboolean has_returned;
} LookupData;

static LookupData *
lookup_data_new_by_name (const char *hostname,
                         int         address_family)
{
  LookupData *data = g_new0 (LookupData, 1);
  data->lookup_type = LOOKUP_BY_NAME;
  g_cond_init (&data->cond);
  g_mutex_init (&data->lock);
  data->lookup_by_name.hostname = g_strdup (hostname);
  data->lookup_by_name.address_family = address_family;
  return g_steal_pointer (&data);
}

static LookupData *
lookup_data_new_by_address (GInetAddress *address)
{
  LookupData *data = g_new0 (LookupData, 1);
  data->lookup_type = LOOKUP_BY_ADDRESS;
  g_cond_init (&data->cond);
  g_mutex_init (&data->lock);
  data->lookup_by_address.address = g_object_ref (address);
  return g_steal_pointer (&data);
}

static LookupData *
lookup_data_new_records (const gchar         *rrname,
                         GResolverRecordType  record_type)
{
  LookupData *data = g_new0 (LookupData, 1);
  data->lookup_type = LOOKUP_RECORDS;
  g_cond_init (&data->cond);
  g_mutex_init (&data->lock);
  data->lookup_records.rrname = g_strdup (rrname);
  data->lookup_records.record_type = record_type;
  return g_steal_pointer (&data);
}

static void
lookup_data_free (LookupData *data)
{
  switch (data->lookup_type) {
  case LOOKUP_BY_NAME:
    g_free (data->lookup_by_name.hostname);
    break;
  case LOOKUP_BY_ADDRESS:
    g_clear_object (&data->lookup_by_address.address);
    break;
  case LOOKUP_RECORDS:
    g_free (data->lookup_records.rrname);
    break;
  default:
    g_assert_not_reached ();
  }

  if (data->timeout_source != NULL)
    {
      g_source_destroy (data->timeout_source);
      g_clear_pointer (&data->timeout_source, g_source_unref);
    }

  if (data->cancellable_source != NULL)
    {
      g_source_destroy (data->cancellable_source);
      g_clear_pointer (&data->cancellable_source, g_source_unref);
    }

  g_mutex_clear (&data->lock);
  g_cond_clear (&data->cond);

  g_free (data);
}

static GList *
do_lookup_by_name (const gchar   *hostname,
                   int            address_family,
                   GCancellable  *cancellable,
                   GError       **error)
{
  struct addrinfo *res = NULL;
  GList *addresses;
  gint retval;
  struct addrinfo addrinfo_hints = { 0 };

#ifdef AI_ADDRCONFIG
  addrinfo_hints.ai_flags = AI_ADDRCONFIG;
#endif
  /* socktype and protocol don't actually matter, they just get copied into the
  * returned addrinfo structures (and then we ignore them). But if
  * we leave them unset, we'll get back duplicate answers.
  */
  addrinfo_hints.ai_socktype = SOCK_STREAM;
  addrinfo_hints.ai_protocol = IPPROTO_TCP;

  addrinfo_hints.ai_family = address_family;
  retval = getaddrinfo (hostname, NULL, &addrinfo_hints, &res);

  if (retval == 0)
    {
      struct addrinfo *ai;
      GSocketAddress *sockaddr;
      GInetAddress *addr;

      addresses = NULL;
      for (ai = res; ai; ai = ai->ai_next)
        {
          sockaddr = g_socket_address_new_from_native (ai->ai_addr, ai->ai_addrlen);
          if (!sockaddr)
            continue;
          if (!G_IS_INET_SOCKET_ADDRESS (sockaddr))
            {
              g_clear_object (&sockaddr);
              continue;
            }

          addr = g_object_ref (g_inet_socket_address_get_address ((GInetSocketAddress *)sockaddr));
          addresses = g_list_prepend (addresses, addr);
          g_object_unref (sockaddr);
        }

      g_clear_pointer (&res, freeaddrinfo);

      if (addresses != NULL)
        {
          addresses = g_list_reverse (addresses);
          return g_steal_pointer (&addresses);
        }
      else
        {
          /* All addresses failed to be converted to GSocketAddresses. */
          g_set_error (error,
                       G_RESOLVER_ERROR,
                       G_RESOLVER_ERROR_NOT_FOUND,
                       _("Error resolving “%s”: %s"),
                       hostname,
                       _("No valid addresses were found"));
          return NULL;
        }
    }
  else
    {
#ifdef G_OS_WIN32
      gchar *error_message = g_win32_error_message (WSAGetLastError ());
#else
      gchar *error_message = g_locale_to_utf8 (gai_strerror (retval), -1, NULL, NULL, NULL);
      if (error_message == NULL)
        error_message = g_strdup ("[Invalid UTF-8]");
#endif

      g_clear_pointer (&res, freeaddrinfo);

      g_set_error (error,
                   G_RESOLVER_ERROR,
                   g_resolver_error_from_addrinfo_error (retval),
                   _("Error resolving “%s”: %s"),
                   hostname, error_message);
      g_free (error_message);

      return NULL;
    }
}

static GList *
lookup_by_name (GResolver     *resolver,
                const gchar   *hostname,
                GCancellable  *cancellable,
                GError       **error)
{
  GThreadedResolver *self = G_THREADED_RESOLVER (resolver);
  GTask *task;
  GList *addresses;
  LookupData *data;

  data = lookup_data_new_by_name (hostname, AF_UNSPEC);
  task = g_task_new (resolver, cancellable, NULL, NULL);
  g_task_set_source_tag (task, lookup_by_name);
  g_task_set_name (task, "[gio] resolver lookup");
  g_task_set_task_data (task, g_steal_pointer (&data), (GDestroyNotify) lookup_data_free);

  run_task_in_thread_pool_sync (self, task);

  addresses = g_task_propagate_pointer (task, error);
  g_object_unref (task);

  return addresses;
}

static int
flags_to_family (GResolverNameLookupFlags flags)
{
  int address_family = AF_UNSPEC;

  if (flags & G_RESOLVER_NAME_LOOKUP_FLAGS_IPV4_ONLY)
    address_family = AF_INET;

  if (flags & G_RESOLVER_NAME_LOOKUP_FLAGS_IPV6_ONLY)
    {
      address_family = AF_INET6;
      /* You can only filter by one family at a time */
      g_return_val_if_fail (!(flags & G_RESOLVER_NAME_LOOKUP_FLAGS_IPV4_ONLY), address_family);
    }

  return address_family;
}

static GList *
lookup_by_name_with_flags (GResolver                 *resolver,
                           const gchar               *hostname,
                           GResolverNameLookupFlags   flags,
                           GCancellable              *cancellable,
                           GError                   **error)
{
  GThreadedResolver *self = G_THREADED_RESOLVER (resolver);
  GTask *task;
  GList *addresses;
  LookupData *data;

  data = lookup_data_new_by_name (hostname, flags_to_family (flags));
  task = g_task_new (resolver, cancellable, NULL, NULL);
  g_task_set_source_tag (task, lookup_by_name_with_flags);
  g_task_set_name (task, "[gio] resolver lookup");
  g_task_set_task_data (task, g_steal_pointer (&data), (GDestroyNotify) lookup_data_free);

  run_task_in_thread_pool_sync (self, task);

  addresses = g_task_propagate_pointer (task, error);
  g_object_unref (task);

  return addresses;
}

static void
lookup_by_name_with_flags_async (GResolver                *resolver,
                                 const gchar              *hostname,
                                 GResolverNameLookupFlags  flags,
                                 GCancellable             *cancellable,
                                 GAsyncReadyCallback       callback,
                                 gpointer                  user_data)
{
  GThreadedResolver *self = G_THREADED_RESOLVER (resolver);
  GTask *task;
  LookupData *data;

  data = lookup_data_new_by_name (hostname, flags_to_family (flags));
  task = g_task_new (resolver, cancellable, callback, user_data);

  g_debug ("%s: starting new lookup for %s with GTask %p, LookupData %p",
           G_STRFUNC, hostname, task, data);

  g_task_set_source_tag (task, lookup_by_name_with_flags_async);
  g_task_set_name (task, "[gio] resolver lookup");
  g_task_set_task_data (task, g_steal_pointer (&data), (GDestroyNotify) lookup_data_free);

  run_task_in_thread_pool_async (self, task);

  g_object_unref (task);
}

static void
lookup_by_name_async (GResolver           *resolver,
                      const gchar         *hostname,
                      GCancellable        *cancellable,
                      GAsyncReadyCallback  callback,
                      gpointer             user_data)
{
  lookup_by_name_with_flags_async (resolver,
                                   hostname,
                                   G_RESOLVER_NAME_LOOKUP_FLAGS_DEFAULT,
                                   cancellable,
                                   callback,
                                   user_data);
}

static GList *
lookup_by_name_finish (GResolver     *resolver,
                       GAsyncResult  *result,
                       GError       **error)
{
  g_return_val_if_fail (g_task_is_valid (result, resolver), NULL);

  return g_task_propagate_pointer (G_TASK (result), error);
}

static GList *
lookup_by_name_with_flags_finish (GResolver     *resolver,
                                  GAsyncResult  *result,
                                  GError       **error)
{
  g_return_val_if_fail (g_task_is_valid (result, resolver), NULL);

  return g_task_propagate_pointer (G_TASK (result), error);
}

static gchar *
do_lookup_by_address (GInetAddress  *address,
                      GCancellable  *cancellable,
                      GError       **error)
{
  struct sockaddr_storage sockaddr_address;
  gsize sockaddr_address_size;
  GSocketAddress *gsockaddr;
  gchar name[NI_MAXHOST];
  gint retval;

  gsockaddr = g_inet_socket_address_new (address, 0);
  g_socket_address_to_native (gsockaddr, (struct sockaddr *)&sockaddr_address,
                              sizeof (sockaddr_address), NULL);
  sockaddr_address_size = g_socket_address_get_native_size (gsockaddr);
  g_object_unref (gsockaddr);

  retval = getnameinfo ((struct sockaddr *) &sockaddr_address, sockaddr_address_size,
                        name, sizeof (name), NULL, 0, NI_NAMEREQD);
  if (retval == 0)
    return g_strdup (name);
  else
    {
      gchar *phys;

#ifdef G_OS_WIN32
      gchar *error_message = g_win32_error_message (WSAGetLastError ());
#else
      gchar *error_message = g_locale_to_utf8 (gai_strerror (retval), -1, NULL, NULL, NULL);
      if (error_message == NULL)
        error_message = g_strdup ("[Invalid UTF-8]");
#endif

      phys = g_inet_address_to_string (address);
      g_set_error (error,
                   G_RESOLVER_ERROR,
                   g_resolver_error_from_addrinfo_error (retval),
                   _("Error reverse-resolving “%s”: %s"),
                   phys ? phys : "(unknown)",
                   error_message);
      g_free (phys);
      g_free (error_message);

      return NULL;
    }
}

static gchar *
lookup_by_address (GResolver        *resolver,
                   GInetAddress     *address,
                   GCancellable     *cancellable,
                   GError          **error)
{
  GThreadedResolver *self = G_THREADED_RESOLVER (resolver);
  LookupData *data = NULL;
  GTask *task;
  gchar *name;

  data = lookup_data_new_by_address (address);
  task = g_task_new (resolver, cancellable, NULL, NULL);
  g_task_set_source_tag (task, lookup_by_address);
  g_task_set_name (task, "[gio] resolver lookup");
  g_task_set_task_data (task, g_steal_pointer (&data), (GDestroyNotify) lookup_data_free);

  run_task_in_thread_pool_sync (self, task);

  name = g_task_propagate_pointer (task, error);
  g_object_unref (task);

  return name;
}

static void
lookup_by_address_async (GResolver           *resolver,
                         GInetAddress        *address,
                         GCancellable        *cancellable,
                         GAsyncReadyCallback  callback,
                         gpointer             user_data)
{
  GThreadedResolver *self = G_THREADED_RESOLVER (resolver);
  LookupData *data = NULL;
  GTask *task;

  data = lookup_data_new_by_address (address);
  task = g_task_new (resolver, cancellable, callback, user_data);
  g_task_set_source_tag (task, lookup_by_address_async);
  g_task_set_name (task, "[gio] resolver lookup");
  g_task_set_task_data (task, g_steal_pointer (&data), (GDestroyNotify) lookup_data_free);

  run_task_in_thread_pool_async (self, task);

  g_object_unref (task);
}

static gchar *
lookup_by_address_finish (GResolver     *resolver,
                          GAsyncResult  *result,
                          GError       **error)
{
  g_return_val_if_fail (g_task_is_valid (result, resolver), NULL);

  return g_task_propagate_pointer (G_TASK (result), error);
}


#if defined(G_OS_UNIX)

#if defined __BIONIC__ && !defined BIND_4_COMPAT
/* Copy from bionic/libc/private/arpa_nameser_compat.h
 * and bionic/libc/private/arpa_nameser.h */
typedef struct {
	unsigned	id :16;		/* query identification number */
#if BYTE_ORDER == BIG_ENDIAN
			/* fields in third byte */
	unsigned	qr: 1;		/* response flag */
	unsigned	opcode: 4;	/* purpose of message */
	unsigned	aa: 1;		/* authoritative answer */
	unsigned	tc: 1;		/* truncated message */
	unsigned	rd: 1;		/* recursion desired */
			/* fields in fourth byte */
	unsigned	ra: 1;		/* recursion available */
	unsigned	unused :1;	/* unused bits (MBZ as of 4.9.3a3) */
	unsigned	ad: 1;		/* authentic data from named */
	unsigned	cd: 1;		/* checking disabled by resolver */
	unsigned	rcode :4;	/* response code */
#endif
#if BYTE_ORDER == LITTLE_ENDIAN || BYTE_ORDER == PDP_ENDIAN
			/* fields in third byte */
	unsigned	rd :1;		/* recursion desired */
	unsigned	tc :1;		/* truncated message */
	unsigned	aa :1;		/* authoritative answer */
	unsigned	opcode :4;	/* purpose of message */
	unsigned	qr :1;		/* response flag */
			/* fields in fourth byte */
	unsigned	rcode :4;	/* response code */
	unsigned	cd: 1;		/* checking disabled by resolver */
	unsigned	ad: 1;		/* authentic data from named */
	unsigned	unused :1;	/* unused bits (MBZ as of 4.9.3a3) */
	unsigned	ra :1;		/* recursion available */
#endif
			/* remaining bytes */
	unsigned	qdcount :16;	/* number of question entries */
	unsigned	ancount :16;	/* number of answer entries */
	unsigned	nscount :16;	/* number of authority entries */
	unsigned	arcount :16;	/* number of resource entries */
} HEADER;

#define NS_INT32SZ	4	/* #/bytes of data in a uint32_t */
#define NS_INT16SZ	2	/* #/bytes of data in a uint16_t */

#define NS_GET16(s, cp) do { \
	const u_char *t_cp = (const u_char *)(cp); \
	(s) = ((uint16_t)t_cp[0] << 8) \
	    | ((uint16_t)t_cp[1]) \
	    ; \
	(cp) += NS_INT16SZ; \
} while (/*CONSTCOND*/0)

#define NS_GET32(l, cp) do { \
	const u_char *t_cp = (const u_char *)(cp); \
	(l) = ((uint32_t)t_cp[0] << 24) \
	    | ((uint32_t)t_cp[1] << 16) \
	    | ((uint32_t)t_cp[2] << 8) \
	    | ((uint32_t)t_cp[3]) \
	    ; \
	(cp) += NS_INT32SZ; \
} while (/*CONSTCOND*/0)

#define	GETSHORT		NS_GET16
#define	GETLONG			NS_GET32

#define C_IN 1

/* From bionic/libc/private/resolv_private.h */
int dn_expand(const u_char *, const u_char *, const u_char *, char *, int);
#define dn_skipname __dn_skipname
int dn_skipname(const u_char *, const u_char *);

/* From bionic/libc/private/arpa_nameser_compat.h */
#define T_MX		ns_t_mx
#define T_TXT		ns_t_txt
#define T_SOA		ns_t_soa
#define T_NS		ns_t_ns

/* From bionic/libc/private/arpa_nameser.h */
typedef enum __ns_type {
	ns_t_invalid = 0,	/* Cookie. */
	ns_t_a = 1,		/* Host address. */
	ns_t_ns = 2,		/* Authoritative server. */
	ns_t_md = 3,		/* Mail destination. */
	ns_t_mf = 4,		/* Mail forwarder. */
	ns_t_cname = 5,		/* Canonical name. */
	ns_t_soa = 6,		/* Start of authority zone. */
	ns_t_mb = 7,		/* Mailbox domain name. */
	ns_t_mg = 8,		/* Mail group member. */
	ns_t_mr = 9,		/* Mail rename name. */
	ns_t_null = 10,		/* Null resource record. */
	ns_t_wks = 11,		/* Well known service. */
	ns_t_ptr = 12,		/* Domain name pointer. */
	ns_t_hinfo = 13,	/* Host information. */
	ns_t_minfo = 14,	/* Mailbox information. */
	ns_t_mx = 15,		/* Mail routing information. */
	ns_t_txt = 16,		/* Text strings. */
	ns_t_rp = 17,		/* Responsible person. */
	ns_t_afsdb = 18,	/* AFS cell database. */
	ns_t_x25 = 19,		/* X_25 calling address. */
	ns_t_isdn = 20,		/* ISDN calling address. */
	ns_t_rt = 21,		/* Router. */
	ns_t_nsap = 22,		/* NSAP address. */
	ns_t_nsap_ptr = 23,	/* Reverse NSAP lookup (deprecated). */
	ns_t_sig = 24,		/* Security signature. */
	ns_t_key = 25,		/* Security key. */
	ns_t_px = 26,		/* X.400 mail mapping. */
	ns_t_gpos = 27,		/* Geographical position (withdrawn). */
	ns_t_aaaa = 28,		/* Ip6 Address. */
	ns_t_loc = 29,		/* Location Information. */
	ns_t_nxt = 30,		/* Next domain (security). */
	ns_t_eid = 31,		/* Endpoint identifier. */
	ns_t_nimloc = 32,	/* Nimrod Locator. */
	ns_t_srv = 33,		/* Server Selection. */
	ns_t_atma = 34,		/* ATM Address */
	ns_t_naptr = 35,	/* Naming Authority PoinTeR */
	ns_t_kx = 36,		/* Key Exchange */
	ns_t_cert = 37,		/* Certification record */
	ns_t_a6 = 38,		/* IPv6 address (deprecates AAAA) */
	ns_t_dname = 39,	/* Non-terminal DNAME (for IPv6) */
	ns_t_sink = 40,		/* Kitchen sink (experimental) */
	ns_t_opt = 41,		/* EDNS0 option (meta-RR) */
	ns_t_apl = 42,		/* Address prefix list (RFC 3123) */
	ns_t_tkey = 249,	/* Transaction key */
	ns_t_tsig = 250,	/* Transaction signature. */
	ns_t_ixfr = 251,	/* Incremental zone transfer. */
	ns_t_axfr = 252,	/* Transfer zone of authority. */
	ns_t_mailb = 253,	/* Transfer mailbox records. */
	ns_t_maila = 254,	/* Transfer mail agent records. */
	ns_t_any = 255,		/* Wildcard match. */
	ns_t_zxfr = 256,	/* BIND-specific, nonstandard. */
	ns_t_max = 65536
} ns_type;

#endif /* __BIONIC__ */

/* Wrapper around dn_expand() which does associated length checks and returns
 * errors as #GError. */
static gboolean
expand_name (const gchar   *rrname,
             const guint8  *answer,
             const guint8  *end,
             const guint8 **p,
             gchar         *namebuf,
             gsize          namebuf_len,
             GError       **error)
{
  int expand_result;

  expand_result = dn_expand (answer, end, *p, namebuf, namebuf_len);
  if (expand_result < 0 || end - *p < expand_result)
    {
      g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_INTERNAL,
                   /* Translators: the placeholder is a DNS record type, such as ‘MX’ or ‘SRV’ */
                   _("Error parsing DNS %s record: malformed DNS packet"), rrname);
      return FALSE;
    }

  *p += expand_result;

  return TRUE;
}

static GVariant *
parse_res_srv (const guint8  *answer,
               const guint8  *end,
               const guint8 **p,
               GError       **error)
{
  gchar namebuf[1024];
  guint16 priority, weight, port;

  if (end - *p < 6)
    {
      g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_INTERNAL,
                   /* Translators: the placeholder is a DNS record type, such as ‘MX’ or ‘SRV’ */
                   _("Error parsing DNS %s record: malformed DNS packet"), "SRV");
      return NULL;
    }

  GETSHORT (priority, *p);
  GETSHORT (weight, *p);
  GETSHORT (port, *p);

  /* RFC 2782 says (on page 4) that “Unless and until permitted by future
   * standards action, name compression is not to be used for this field.”, so
   * technically we shouldn’t be expanding names here for SRV records.
   *
   * However, other DNS resolvers (such as systemd[1]) do, and it seems in
   * keeping with the principle of being liberal in what you accept and strict
   * in what you emit. It also seems harmless.
   *
   * An earlier version of the RFC, RFC 2052 (now obsolete) specified that name
   * compression *was* to be used for SRV targets[2].
   *
   * See discussion on https://gitlab.gnome.org/GNOME/glib/-/issues/2622.
   *
   * [1]: https://github.com/yuwata/systemd/blob/2d23cc3c07c49722ce93170737b3efd2692a2d08/src/resolve/resolved-dns-packet.c#L1674
   * [2]: https://datatracker.ietf.org/doc/html/rfc2052#page-3
   */
  if (!expand_name ("SRV", answer, end, p, namebuf, sizeof (namebuf), error))
    return NULL;

  return g_variant_new ("(qqqs)",
                        priority,
                        weight,
                        port,
                        namebuf);
}

static GVariant *
parse_res_soa (const guint8  *answer,
               const guint8  *end,
               const guint8 **p,
               GError       **error)
{
  gchar mnamebuf[1024];
  gchar rnamebuf[1024];
  guint32 serial, refresh, retry, expire, ttl;

  if (!expand_name ("SOA", answer, end, p, mnamebuf, sizeof (mnamebuf), error))
    return NULL;

  if (!expand_name ("SOA", answer, end, p, rnamebuf, sizeof (rnamebuf), error))
    return NULL;

  if (end - *p < 20)
    {
      g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_INTERNAL,
                   /* Translators: the placeholder is a DNS record type, such as ‘MX’ or ‘SRV’ */
                   _("Error parsing DNS %s record: malformed DNS packet"), "SOA");
      return NULL;
    }

  GETLONG (serial, *p);
  GETLONG (refresh, *p);
  GETLONG (retry, *p);
  GETLONG (expire, *p);
  GETLONG (ttl, *p);

  return g_variant_new ("(ssuuuuu)",
                        mnamebuf,
                        rnamebuf,
                        serial,
                        refresh,
                        retry,
                        expire,
                        ttl);
}

static GVariant *
parse_res_ns (const guint8  *answer,
              const guint8  *end,
              const guint8 **p,
              GError       **error)
{
  gchar namebuf[1024];

  if (!expand_name ("NS", answer, end, p, namebuf, sizeof (namebuf), error))
    return NULL;

  return g_variant_new ("(s)", namebuf);
}

static GVariant *
parse_res_mx (const guint8  *answer,
              const guint8  *end,
              const guint8 **p,
              GError       **error)
{
  gchar namebuf[1024];
  guint16 preference;

  if (end - *p < 2)
    {
      g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_INTERNAL,
                   /* Translators: the placeholder is a DNS record type, such as ‘MX’ or ‘SRV’ */
                   _("Error parsing DNS %s record: malformed DNS packet"), "MX");
      return NULL;
    }

  GETSHORT (preference, *p);

  if (!expand_name ("MX", answer, end, p, namebuf, sizeof (namebuf), error))
    return NULL;

  return g_variant_new ("(qs)",
                        preference,
                        namebuf);
}

static GVariant *
parse_res_txt (const guint8  *answer,
               const guint8  *end,
               const guint8 **p,
               GError       **error)
{
  GVariant *record;
  GPtrArray *array;
  const guint8 *at = *p;
  gsize len;

  if (end - *p == 0)
    {
      g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_INTERNAL,
                   /* Translators: the placeholder is a DNS record type, such as ‘MX’ or ‘SRV’ */
                   _("Error parsing DNS %s record: malformed DNS packet"), "TXT");
      return NULL;
    }

  array = g_ptr_array_new_with_free_func (g_free);
  while (at < end)
    {
      len = *(at++);
      if (len > (gsize) (end - at))
        {
          g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_INTERNAL,
                       /* Translators: the placeholder is a DNS record type, such as ‘MX’ or ‘SRV’ */
                       _("Error parsing DNS %s record: malformed DNS packet"), "TXT");
          g_ptr_array_free (array, TRUE);
          return NULL;
        }

      g_ptr_array_add (array, g_strndup ((gchar *)at, len));
      at += len;
    }

  *p = at;
  record = g_variant_new ("(@as)",
                          g_variant_new_strv ((const gchar **)array->pdata, array->len));
  g_ptr_array_free (array, TRUE);
  return record;
}

gint
g_resolver_record_type_to_rrtype (GResolverRecordType type)
{
  switch (type)
  {
    case G_RESOLVER_RECORD_SRV:
      return T_SRV;
    case G_RESOLVER_RECORD_TXT:
      return T_TXT;
    case G_RESOLVER_RECORD_SOA:
      return T_SOA;
    case G_RESOLVER_RECORD_NS:
      return T_NS;
    case G_RESOLVER_RECORD_MX:
      return T_MX;
  }
  g_return_val_if_reached (-1);
}

GList *
g_resolver_records_from_res_query (const gchar      *rrname,
                                   gint              rrtype,
                                   const guint8     *answer,
                                   gssize            len,
                                   gint              herr,
                                   GError          **error)
{
  uint16_t count;
  gchar namebuf[1024];
  const guint8 *end, *p;
  guint16 type, qclass, rdlength;
  const HEADER *header;
  GList *records;
  GVariant *record;
  gsize len_unsigned;
  GError *parsing_error = NULL;

  if (len <= 0)
    {
      if (len == 0 || herr == HOST_NOT_FOUND || herr == NO_DATA)
        {
          g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_NOT_FOUND,
                       _("No DNS record of the requested type for “%s”"), rrname);
        }
      else if (herr == TRY_AGAIN)
        {
          g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_TEMPORARY_FAILURE,
                       _("Temporarily unable to resolve “%s”"), rrname);
        }
      else
        {
          g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_INTERNAL,
                       _("Error resolving “%s”"), rrname);
        }

      return NULL;
    }

  /* We know len ≥ 0 now. */
  len_unsigned = (gsize) len;

  if (len_unsigned < sizeof (HEADER))
    {
      g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_INTERNAL,
                   /* Translators: the first placeholder is a domain name, the
                    * second is an error message */
                   _("Error resolving “%s”: %s"), rrname, _("Malformed DNS packet"));
      return NULL;
    }

  records = NULL;

  header = (HEADER *)answer;
  p = answer + sizeof (HEADER);
  end = answer + len_unsigned;

  /* Skip query */
  count = ntohs (header->qdcount);
  while (count-- && p < end)
    {
      int expand_result;

      expand_result = dn_expand (answer, end, p, namebuf, sizeof (namebuf));
      if (expand_result < 0 || end - p < expand_result + 4)
        {
          /* Not possible to recover parsing as the length of the rest of the
           * record is unknown or is too short. */
          g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_INTERNAL,
                       /* Translators: the first placeholder is a domain name, the
                        * second is an error message */
                       _("Error resolving “%s”: %s"), rrname, _("Malformed DNS packet"));
          return NULL;
        }

      p += expand_result;
      p += 4;  /* skip TYPE and CLASS */

      /* To silence gcc warnings */
      namebuf[0] = namebuf[1];
    }

  /* Read answers */
  count = ntohs (header->ancount);
  while (count-- && p < end)
    {
      int expand_result;

      expand_result = dn_expand (answer, end, p, namebuf, sizeof (namebuf));
      if (expand_result < 0 || end - p < expand_result + 10)
        {
          /* Not possible to recover parsing as the length of the rest of the
           * record is unknown or is too short. */
          g_set_error (&parsing_error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_INTERNAL,
                       /* Translators: the first placeholder is a domain name, the
                        * second is an error message */
                       _("Error resolving “%s”: %s"), rrname, _("Malformed DNS packet"));
          break;
        }

      p += expand_result;
      GETSHORT (type, p);
      GETSHORT (qclass, p);
      p += 4; /* ignore the ttl (type=long) value */
      GETSHORT (rdlength, p);

      if (end - p < rdlength)
        {
          g_set_error (&parsing_error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_INTERNAL,
                       /* Translators: the first placeholder is a domain name, the
                        * second is an error message */
                       _("Error resolving “%s”: %s"), rrname, _("Malformed DNS packet"));
          break;
        }

      if (type != rrtype || qclass != C_IN)
        {
          p += rdlength;
          continue;
        }

      switch (rrtype)
        {
        case T_SRV:
          record = parse_res_srv (answer, p + rdlength, &p, &parsing_error);
          break;
        case T_MX:
          record = parse_res_mx (answer, p + rdlength, &p, &parsing_error);
          break;
        case T_SOA:
          record = parse_res_soa (answer, p + rdlength, &p, &parsing_error);
          break;
        case T_NS:
          record = parse_res_ns (answer, p + rdlength, &p, &parsing_error);
          break;
        case T_TXT:
          record = parse_res_txt (answer, p + rdlength, &p, &parsing_error);
          break;
        default:
          g_debug ("Unrecognised DNS record type %u", rrtype);
          record = NULL;
          break;
        }

      if (record != NULL)
        records = g_list_prepend (records, record);

      if (parsing_error != NULL)
        break;
    }

  if (parsing_error != NULL)
    {
      g_propagate_prefixed_error (error, parsing_error, _("Failed to parse DNS response for “%s”: "), rrname);
      g_list_free_full (records, (GDestroyNotify)g_variant_unref);
      return NULL;
    }
  else if (records == NULL)
    {
      g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_NOT_FOUND,
                   _("No DNS record of the requested type for “%s”"), rrname);

      return NULL;
    }
  else
    return records;
}

#elif defined(G_OS_WIN32)

static GVariant *
parse_dns_srv (DNS_RECORDA *rec)
{
  return g_variant_new ("(qqqs)",
                        (guint16)rec->Data.SRV.wPriority,
                        (guint16)rec->Data.SRV.wWeight,
                        (guint16)rec->Data.SRV.wPort,
                        rec->Data.SRV.pNameTarget);
}

static GVariant *
parse_dns_soa (DNS_RECORDA *rec)
{
  return g_variant_new ("(ssuuuuu)",
                        rec->Data.SOA.pNamePrimaryServer,
                        rec->Data.SOA.pNameAdministrator,
                        (guint32)rec->Data.SOA.dwSerialNo,
                        (guint32)rec->Data.SOA.dwRefresh,
                        (guint32)rec->Data.SOA.dwRetry,
                        (guint32)rec->Data.SOA.dwExpire,
                        (guint32)rec->Data.SOA.dwDefaultTtl);
}

static GVariant *
parse_dns_ns (DNS_RECORDA *rec)
{
  return g_variant_new ("(s)", rec->Data.NS.pNameHost);
}

static GVariant *
parse_dns_mx (DNS_RECORDA *rec)
{
  return g_variant_new ("(qs)",
                        (guint16)rec->Data.MX.wPreference,
                        rec->Data.MX.pNameExchange);
}

static GVariant *
parse_dns_txt (DNS_RECORDA *rec)
{
  GVariant *record;
  GPtrArray *array;
  DWORD i;

  array = g_ptr_array_new ();
  for (i = 0; i < rec->Data.TXT.dwStringCount; i++)
    g_ptr_array_add (array, rec->Data.TXT.pStringArray[i]);
  record = g_variant_new ("(@as)",
                          g_variant_new_strv ((const gchar **)array->pdata, array->len));
  g_ptr_array_free (array, TRUE);
  return record;
}

static WORD
g_resolver_record_type_to_dnstype (GResolverRecordType type)
{
  switch (type)
  {
    case G_RESOLVER_RECORD_SRV:
      return DNS_TYPE_SRV;
    case G_RESOLVER_RECORD_TXT:
      return DNS_TYPE_TEXT;
    case G_RESOLVER_RECORD_SOA:
      return DNS_TYPE_SOA;
    case G_RESOLVER_RECORD_NS:
      return DNS_TYPE_NS;
    case G_RESOLVER_RECORD_MX:
      return DNS_TYPE_MX;
  }
  g_return_val_if_reached (-1);
}

static GList *
g_resolver_records_from_DnsQuery (const gchar  *rrname,
                                  WORD          dnstype,
                                  DNS_STATUS    status,
                                  DNS_RECORDA  *results,
                                  GError      **error)
{
  DNS_RECORDA *rec;
  gpointer record;
  GList *records;

  if (status != ERROR_SUCCESS)
    {
      if (status == DNS_ERROR_RCODE_NAME_ERROR)
        {
          g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_NOT_FOUND,
                       _("No DNS record of the requested type for “%s”"), rrname);
        }
      else if (status == DNS_ERROR_RCODE_SERVER_FAILURE)
        {
          g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_TEMPORARY_FAILURE,
                       _("Temporarily unable to resolve “%s”"), rrname);
        }
      else
        {
          g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_INTERNAL,
                       _("Error resolving “%s”"), rrname);
        }

      return NULL;
    }

  records = NULL;
  for (rec = results; rec; rec = rec->pNext)
    {
      if (rec->wType != dnstype)
        continue;
      switch (dnstype)
        {
        case DNS_TYPE_SRV:
          record = parse_dns_srv (rec);
          break;
        case DNS_TYPE_SOA:
          record = parse_dns_soa (rec);
          break;
        case DNS_TYPE_NS:
          record = parse_dns_ns (rec);
          break;
        case DNS_TYPE_MX:
          record = parse_dns_mx (rec);
          break;
        case DNS_TYPE_TEXT:
          record = parse_dns_txt (rec);
          break;
        default:
          g_warn_if_reached ();
          record = NULL;
          break;
        }
      if (record != NULL)
        records = g_list_prepend (records, g_variant_ref_sink (record));
    }

  if (records == NULL)
    {
      g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_NOT_FOUND,
                   _("No DNS record of the requested type for “%s”"), rrname);

      return NULL;
    }
  else
    return records;
}

#endif

static void
free_records (GList *records)
{
  g_list_free_full (records, (GDestroyNotify) g_variant_unref);
}

#if defined(G_OS_UNIX)
#ifdef __BIONIC__
#ifndef C_IN
#define C_IN 1
#endif
int res_query(const char *, int, int, u_char *, int);
#endif
#endif

static GList *
do_lookup_records (const gchar          *rrname,
                   GResolverRecordType   record_type,
                   GCancellable         *cancellable,
                   GError              **error)
{
  GList *records;

#if defined(G_OS_UNIX)
  gint len = 512;
  gint herr;
  GByteArray *answer;
  gint rrtype;

#ifdef HAVE_RES_NQUERY
  /* Load the resolver state. This is done once per worker thread, and the
   * #GResolver::reload signal is ignored (since we always reload). This could
   * be improved by having an explicit worker thread pool, with each thread
   * containing some state which is initialised at thread creation time and
   * updated in response to #GResolver::reload.
   *
   * What we have currently is not particularly worse than using res_query() in
   * worker threads, since it would transparently call res_init() for each new
   * worker thread. (Although the workers would get reused by the
   * #GThreadPool.)
   *
   * FreeBSD requires the state to be zero-filled before calling res_ninit(). */
  struct __res_state res = { 0, };
  if (res_ninit (&res) != 0)
    {
      g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_INTERNAL,
                   _("Error resolving “%s”"), rrname);
      return NULL;
    }
#endif

  rrtype = g_resolver_record_type_to_rrtype (record_type);
  answer = g_byte_array_new ();
  for (;;)
    {
      g_byte_array_set_size (answer, len * 2);
#if defined(HAVE_RES_NQUERY)
      len = res_nquery (&res, rrname, C_IN, rrtype, answer->data, answer->len);
#else
      len = res_query (rrname, C_IN, rrtype, answer->data, answer->len);
#endif

      /* If answer fit in the buffer then we're done */
      if (len < 0 || len < (gint)answer->len)
        break;

      /*
       * On overflow some res_query's return the length needed, others
       * return the full length entered. This code works in either case.
       */
    }

  herr = h_errno;
  records = g_resolver_records_from_res_query (rrname, rrtype, answer->data, len, herr, error);
  g_byte_array_free (answer, TRUE);

#ifdef HAVE_RES_NQUERY

#if defined(HAVE_RES_NDESTROY)
  res_ndestroy (&res);
#elif defined(HAVE_RES_NCLOSE)
  res_nclose (&res);
#elif defined(HAVE_RES_NINIT)
#error "Your platform has res_ninit() but not res_nclose() or res_ndestroy(). Please file a bug at https://gitlab.gnome.org/GNOME/glib/issues/new"
#endif

#endif  /* HAVE_RES_NQUERY */

#else

  DNS_STATUS status;
  DNS_RECORDA *results = NULL;
  WORD dnstype;

  /* Work around differences in Windows SDK and mingw-w64 headers */
#ifdef _MSC_VER
  typedef DNS_RECORDW * PDNS_RECORD_UTF8_;
#else
  typedef DNS_RECORDA * PDNS_RECORD_UTF8_;
#endif

  dnstype = g_resolver_record_type_to_dnstype (record_type);
  status = DnsQuery_UTF8 (rrname, dnstype, DNS_QUERY_STANDARD, NULL, (PDNS_RECORD_UTF8_*)&results, NULL);
  records = g_resolver_records_from_DnsQuery (rrname, dnstype, status, results, error);
  if (results != NULL)
    DnsRecordListFree (results, DnsFreeRecordList);

#endif

  return g_steal_pointer (&records);
}

static GList *
lookup_records (GResolver              *resolver,
                const gchar            *rrname,
                GResolverRecordType     record_type,
                GCancellable           *cancellable,
                GError                **error)
{
  GThreadedResolver *self = G_THREADED_RESOLVER (resolver);
  GTask *task;
  GList *records;
  LookupData *data = NULL;

  task = g_task_new (resolver, cancellable, NULL, NULL);
  g_task_set_source_tag (task, lookup_records);
  g_task_set_name (task, "[gio] resolver lookup records");

  data = lookup_data_new_records (rrname, record_type);
  g_task_set_task_data (task, g_steal_pointer (&data), (GDestroyNotify) lookup_data_free);

  run_task_in_thread_pool_sync (self, task);

  records = g_task_propagate_pointer (task, error);
  g_object_unref (task);

  return records;
}

static void
lookup_records_async (GResolver           *resolver,
                      const char          *rrname,
                      GResolverRecordType  record_type,
                      GCancellable        *cancellable,
                      GAsyncReadyCallback  callback,
                      gpointer             user_data)
{
  GThreadedResolver *self = G_THREADED_RESOLVER (resolver);
  GTask *task;
  LookupData *data = NULL;

  task = g_task_new (resolver, cancellable, callback, user_data);
  g_task_set_source_tag (task, lookup_records_async);
  g_task_set_name (task, "[gio] resolver lookup records");

  data = lookup_data_new_records (rrname, record_type);
  g_task_set_task_data (task, g_steal_pointer (&data), (GDestroyNotify) lookup_data_free);

  run_task_in_thread_pool_async (self, task);

  g_object_unref (task);
}

static GList *
lookup_records_finish (GResolver     *resolver,
                       GAsyncResult  *result,
                       GError       **error)
{
  g_return_val_if_fail (g_task_is_valid (result, resolver), NULL);

  return g_task_propagate_pointer (G_TASK (result), error);
}

/* Will be called in the GLib worker thread, so must lock all accesses to shared
 * data. */
static gboolean
timeout_cb (gpointer user_data)
{
  GWeakRef *weak_task = user_data;
  GTask *task = NULL;  /* (owned) */
  LookupData *data;
  gboolean should_return;

  task = g_weak_ref_get (weak_task);
  if (task == NULL)
    return G_SOURCE_REMOVE;

  data = g_task_get_task_data (task);

  g_mutex_lock (&data->lock);

  should_return = g_atomic_int_compare_and_exchange (&data->will_return, NOT_YET, TIMED_OUT);
  g_clear_pointer (&data->timeout_source, g_source_unref);

  g_mutex_unlock (&data->lock);

  if (should_return)
    {
      g_task_return_new_error_literal (task, G_IO_ERROR, G_IO_ERROR_TIMED_OUT,
                                       _("Socket I/O timed out"));
    }

  /* Signal completion of the task. */
  g_mutex_lock (&data->lock);
  data->has_returned = TRUE;
  g_cond_broadcast (&data->cond);
  g_mutex_unlock (&data->lock);

  g_object_unref (task);

  return G_SOURCE_REMOVE;
}

/* Will be called in the GLib worker thread, so must lock all accesses to shared
 * data. */
static gboolean
cancelled_cb (GCancellable *cancellable,
              gpointer      user_data)
{
  GWeakRef *weak_task = user_data;
  GTask *task = NULL;  /* (owned) */
  LookupData *data;
  gboolean should_return;

  task = g_weak_ref_get (weak_task);
  if (task == NULL)
    return G_SOURCE_REMOVE;

  data = g_task_get_task_data (task);

  g_mutex_lock (&data->lock);

  g_assert (g_cancellable_is_cancelled (cancellable));
  should_return = g_atomic_int_compare_and_exchange (&data->will_return, NOT_YET, CANCELLED);
  g_clear_pointer (&data->cancellable_source, g_source_unref);

  g_mutex_unlock (&data->lock);

  if (should_return)
    g_task_return_error_if_cancelled (task);

  /* Signal completion of the task. */
  g_mutex_lock (&data->lock);
  data->has_returned = TRUE;
  g_cond_broadcast (&data->cond);
  g_mutex_unlock (&data->lock);

  g_object_unref (task);

  return G_SOURCE_REMOVE;
}

static void
weak_ref_clear_and_free (GWeakRef *weak_ref)
{
  g_weak_ref_clear (weak_ref);
  g_free (weak_ref);
}

static void
run_task_in_thread_pool_async (GThreadedResolver *self,
                               GTask             *task)
{
  LookupData *data = g_task_get_task_data (task);
  guint timeout_ms = g_resolver_get_timeout (G_RESOLVER (self));
  GCancellable *cancellable = g_task_get_cancellable (task);

  g_mutex_lock (&data->lock);

  g_thread_pool_push (self->thread_pool, g_object_ref (task), NULL);

  if (timeout_ms != 0)
    {
      GWeakRef *weak_task = g_new0 (GWeakRef, 1);
      g_weak_ref_set (weak_task, task);

      data->timeout_source = g_timeout_source_new (timeout_ms);
      g_source_set_static_name (data->timeout_source, "[gio] threaded resolver timeout");
      g_source_set_callback (data->timeout_source, G_SOURCE_FUNC (timeout_cb), g_steal_pointer (&weak_task), (GDestroyNotify) weak_ref_clear_and_free);
      g_source_attach (data->timeout_source, GLIB_PRIVATE_CALL (g_get_worker_context) ());
    }

  if (cancellable != NULL)
    {
      GWeakRef *weak_task = g_new0 (GWeakRef, 1);
      g_weak_ref_set (weak_task, task);

      data->cancellable_source = g_cancellable_source_new (cancellable);
      g_source_set_static_name (data->cancellable_source, "[gio] threaded resolver cancellable");
      g_source_set_callback (data->cancellable_source, G_SOURCE_FUNC (cancelled_cb), g_steal_pointer (&weak_task), (GDestroyNotify) weak_ref_clear_and_free);
      g_source_attach (data->cancellable_source, GLIB_PRIVATE_CALL (g_get_worker_context) ());
    }

  g_mutex_unlock (&data->lock);
}

static void
run_task_in_thread_pool_sync (GThreadedResolver *self,
                              GTask             *task)
{
  LookupData *data = g_task_get_task_data (task);

  run_task_in_thread_pool_async (self, task);

  g_mutex_lock (&data->lock);
  while (!data->has_returned)
    g_cond_wait (&data->cond, &data->lock);
  g_mutex_unlock (&data->lock);
}

static void
threaded_resolver_worker_cb (gpointer task_data,
                             gpointer user_data)
{
  GTask *task = G_TASK (g_steal_pointer (&task_data));
  LookupData *data = g_task_get_task_data (task);
  GCancellable *cancellable = g_task_get_cancellable (task);
  GError *local_error = NULL;
  gboolean should_return;

  switch (data->lookup_type) {
  case LOOKUP_BY_NAME:
    {
      GList *addresses = do_lookup_by_name (data->lookup_by_name.hostname,
                                            data->lookup_by_name.address_family,
                                            cancellable,
                                            &local_error);

      g_mutex_lock (&data->lock);
      should_return = g_atomic_int_compare_and_exchange (&data->will_return, NOT_YET, COMPLETED);
      g_mutex_unlock (&data->lock);

      if (should_return)
        {
          if (addresses != NULL)
            g_task_return_pointer (task, g_steal_pointer (&addresses), (GDestroyNotify) g_resolver_free_addresses);
          else
            g_task_return_error (task, g_steal_pointer (&local_error));
        }

      g_clear_pointer (&addresses, g_resolver_free_addresses);
      g_clear_error (&local_error);
    }
    break;
  case LOOKUP_BY_ADDRESS:
    {
      gchar *name = do_lookup_by_address (data->lookup_by_address.address,
                                          cancellable,
                                          &local_error);

      g_mutex_lock (&data->lock);
      should_return = g_atomic_int_compare_and_exchange (&data->will_return, NOT_YET, COMPLETED);
      g_mutex_unlock (&data->lock);

      if (should_return)
        {
          if (name != NULL)
            g_task_return_pointer (task, g_steal_pointer (&name), g_free);
          else
            g_task_return_error (task, g_steal_pointer (&local_error));
        }

      g_clear_pointer (&name, g_free);
      g_clear_error (&local_error);
    }
    break;
  case LOOKUP_RECORDS:
    {
      GList *records = do_lookup_records (data->lookup_records.rrname,
                                          data->lookup_records.record_type,
                                          cancellable,
                                          &local_error);

      g_mutex_lock (&data->lock);
      should_return = g_atomic_int_compare_and_exchange (&data->will_return, NOT_YET, COMPLETED);
      g_mutex_unlock (&data->lock);

      if (should_return)
        {
          if (records != NULL)
            g_task_return_pointer (task, g_steal_pointer (&records), (GDestroyNotify) free_records);
          else
            g_task_return_error (task, g_steal_pointer (&local_error));
        }

      g_clear_pointer (&records, free_records);
      g_clear_error (&local_error);
    }
    break;
  default:
    g_assert_not_reached ();
  }

  /* Signal completion of a task. */
  g_mutex_lock (&data->lock);
  data->has_returned = TRUE;
  g_cond_broadcast (&data->cond);
  g_mutex_unlock (&data->lock);

  g_object_unref (task);
}

static void
g_threaded_resolver_class_init (GThreadedResolverClass *threaded_class)
{
  GObjectClass *object_class = G_OBJECT_CLASS (threaded_class);
  GResolverClass *resolver_class = G_RESOLVER_CLASS (threaded_class);

  object_class->finalize = g_threaded_resolver_finalize;

  resolver_class->lookup_by_name                   = lookup_by_name;
  resolver_class->lookup_by_name_async             = lookup_by_name_async;
  resolver_class->lookup_by_name_finish            = lookup_by_name_finish;
  resolver_class->lookup_by_name_with_flags        = lookup_by_name_with_flags;
  resolver_class->lookup_by_name_with_flags_async  = lookup_by_name_with_flags_async;
  resolver_class->lookup_by_name_with_flags_finish = lookup_by_name_with_flags_finish;
  resolver_class->lookup_by_address                = lookup_by_address;
  resolver_class->lookup_by_address_async          = lookup_by_address_async;
  resolver_class->lookup_by_address_finish         = lookup_by_address_finish;
  resolver_class->lookup_records                   = lookup_records;
  resolver_class->lookup_records_async             = lookup_records_async;
  resolver_class->lookup_records_finish            = lookup_records_finish;
}