/* -*- 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.

 *

 * 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 "gthreadedresolver.h"

#include "gnetworkingprivate.h"

#include "gcancellable.h"

#include "ginetaddress.h"

#include "ginetsocketaddress.h"

#include "gtask.h"

#include "gsocketaddress.h"

#include "gsrvtarget.h"

G_DEFINE_TYPE (GThreadedResolver, g_threaded_resolver, G_TYPE_RESOLVER)

static void

g_threaded_resolver_init (GThreadedResolver *gtr)

{

}

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 {

  char *hostname;

  int address_family;

} LookupData;

static LookupData *

lookup_data_new (const char *hostname,

                 int         address_family)

{

  LookupData *data = g_new (LookupData, 1);

  data->hostname = g_strdup (hostname);

  data->address_family = address_family;

  return data;

}

static void

lookup_data_free (LookupData *data)

{

  g_free (data->hostname);

  g_free (data);

}

static void

do_lookup_by_name (GTask         *task,

                   gpointer       source_object,

                   gpointer       task_data,

                   GCancellable  *cancellable)

{

  LookupData *lookup_data = task_data;

  const char *hostname = lookup_data->hostname;

  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 = lookup_data->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);

        }

      if (addresses != NULL)

        {

          addresses = g_list_reverse (addresses);

          g_task_return_pointer (task, addresses,

                                 (GDestroyNotify)g_resolver_free_addresses);

        }

      else

        {

          /* All addresses failed to be converted to GSocketAddresses. */

          g_task_return_new_error (task,

                                   G_RESOLVER_ERROR,

                                   G_RESOLVER_ERROR_NOT_FOUND,

                                   _("Error resolving “%s”: %s"),

                                   hostname,

                                   _("No valid addresses were found"));

        }

    }

  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_task_return_new_error (task,

                               G_RESOLVER_ERROR,

                               g_resolver_error_from_addrinfo_error (retval),

                               _("Error resolving “%s”: %s"),

                               hostname, error_message);

      g_free (error_message);

    }

  if (res)

    freeaddrinfo (res);

}

static GList *

lookup_by_name (GResolver     *resolver,

                const gchar   *hostname,

                GCancellable  *cancellable,

                GError       **error)

{

  GTask *task;

  GList *addresses;

  LookupData *data;

  data = lookup_data_new (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, data, (GDestroyNotify)lookup_data_free);

  g_task_set_return_on_cancel (task, TRUE);

  g_task_run_in_thread_sync (task, do_lookup_by_name);

  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)

{

  GTask *task;

  GList *addresses;

  LookupData *data;

  data = lookup_data_new (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, data, (GDestroyNotify)lookup_data_free);

  g_task_set_return_on_cancel (task, TRUE);

  g_task_run_in_thread_sync (task, do_lookup_by_name);

  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)

{

  GTask *task;

  LookupData *data;

  data = lookup_data_new (hostname, flags_to_family (flags));

  task = g_task_new (resolver, cancellable, callback, user_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, data, (GDestroyNotify)lookup_data_free);

  g_task_set_return_on_cancel (task, TRUE);

  g_task_run_in_thread (task, do_lookup_by_name);

  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 void

do_lookup_by_address (GTask         *task,

                      gpointer       source_object,

                      gpointer       task_data,

                      GCancellable  *cancellable)

{

  GInetAddress *address = task_data;

  struct sockaddr_storage sockaddr;

  gsize sockaddr_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,

                              sizeof (sockaddr), NULL);

  sockaddr_size = g_socket_address_get_native_size (gsockaddr);

  g_object_unref (gsockaddr);

  retval = getnameinfo ((struct sockaddr *)&sockaddr, sockaddr_size,

                        name, sizeof (name), NULL, 0, NI_NAMEREQD);

  if (retval == 0)

    g_task_return_pointer (task, g_strdup (name), g_free);

  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_task_return_new_error (task,

                               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);

    }

}

static gchar *

lookup_by_address (GResolver        *resolver,

                   GInetAddress     *address,

                   GCancellable     *cancellable,

                   GError          **error)

{

  GTask *task;

  gchar *name;

  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_object_ref (address), g_object_unref);

  g_task_set_return_on_cancel (task, TRUE);

  g_task_run_in_thread_sync (task, do_lookup_by_address);

  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)

{

  GTask *task;

  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_object_ref (address), g_object_unref);

  g_task_set_return_on_cancel (task, TRUE);

  g_task_run_in_thread (task, do_lookup_by_address);

  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__ */

static GVariant *

parse_res_srv (guchar  *answer,

               guchar  *end,

               guchar **p)

{

  gchar namebuf[1024];

  guint16 priority, weight, port;

  GETSHORT (priority, *p);

  GETSHORT (weight, *p);

  GETSHORT (port, *p);

  *p += dn_expand (answer, end, *p, namebuf, sizeof (namebuf));

  return g_variant_new ("(qqqs)",

                        priority,

                        weight,

                        port,

                        namebuf);

}

static GVariant *

parse_res_soa (guchar  *answer,

               guchar  *end,

               guchar **p)

{

  gchar mnamebuf[1024];

  gchar rnamebuf[1024];

  guint32 serial, refresh, retry, expire, ttl;

  *p += dn_expand (answer, end, *p, mnamebuf, sizeof (mnamebuf));

  *p += dn_expand (answer, end, *p, rnamebuf, sizeof (rnamebuf));

  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 (guchar  *answer,

              guchar  *end,

              guchar **p)

{

  gchar namebuf[1024];

  *p += dn_expand (answer, end, *p, namebuf, sizeof (namebuf));

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

}

static GVariant *

parse_res_mx (guchar  *answer,

              guchar  *end,

              guchar **p)

{

  gchar namebuf[1024];

  guint16 preference;

  GETSHORT (preference, *p);

  *p += dn_expand (answer, end, *p, namebuf, sizeof (namebuf));

  return g_variant_new ("(qs)",

                        preference,

                        namebuf);

}

static GVariant *

parse_res_txt (guchar  *answer,

               guchar  *end,

               guchar **p)

{

  GVariant *record;

  GPtrArray *array;

  guchar *at = *p;

  gsize len;

  array = g_ptr_array_new_with_free_func (g_free);

  while (at < end)

    {

      len = *(at++);

      if (len > (gsize) (end - at))

        break;

      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;

}

static 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);

}

static GList *

g_resolver_records_from_res_query (const gchar      *rrname,

                                   gint              rrtype,

                                   guchar           *answer,

                                   gint              len,

                                   gint              herr,

                                   GError          **error)

{

  gint count;

  gchar namebuf[1024];

  guchar *end, *p;

  guint16 type, qclass, rdlength;

  HEADER *header;

  GList *records;

  GVariant *record;

  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;

    }

  records = NULL;

  header = (HEADER *)answer;

  p = answer + sizeof (HEADER);

  end = answer + len;

  /* Skip query */

  count = ntohs (header->qdcount);

  while (count-- && p < end)

    {

      p += dn_expand (answer, end, p, namebuf, sizeof (namebuf));

      p += 4;

      /* To silence gcc warnings */

      namebuf[0] = namebuf[1];

    }

  /* Read answers */

  count = ntohs (header->ancount);

  while (count-- && p < end)

    {

      p += dn_expand (answer, end, p, namebuf, sizeof (namebuf));

      GETSHORT (type, p);

      GETSHORT (qclass, p);

      p += 4; /* ignore the ttl (type=long) value */

      GETSHORT (rdlength, p);

      if (type != rrtype || qclass != C_IN)

        {

          p += rdlength;

          continue;

        }

      switch (rrtype)

        {

        case T_SRV:

          record = parse_res_srv (answer, end, &p);

          break;

        case T_MX:

          record = parse_res_mx (answer, end, &p);

          break;

        case T_SOA:

          record = parse_res_soa (answer, end, &p);

          break;

        case T_NS:

          record = parse_res_ns (answer, end, &p);

          break;

        case T_TXT:

          record = parse_res_txt (answer, p + rdlength, &p);

          break;

        default:

          g_warn_if_reached ();

          record = NULL;

          break;

        }

      if (record != NULL)

        records = g_list_prepend (records, 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;

}

#elif defined(G_OS_WIN32)

static GVariant *

parse_dns_srv (DNS_RECORD *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_RECORD *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_RECORD *rec)

{

  return g_variant_new ("(s)", rec->Data.NS.pNameHost);

}

static GVariant *

parse_dns_mx (DNS_RECORD *rec)

{

  return g_variant_new ("(qs)",

                        (guint16)rec->Data.MX.wPreference,

                        rec->Data.MX.pNameExchange);

}

static GVariant *

parse_dns_txt (DNS_RECORD *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_RECORD   *results,

                                  GError      **error)

{

  DNS_RECORD *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

typedef struct {

  char *rrname;

  GResolverRecordType record_type;

} LookupRecordsData;

static void

free_lookup_records_data (LookupRecordsData *lrd)

{

  g_free (lrd->rrname);

  g_slice_free (LookupRecordsData, lrd);

}

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 void

do_lookup_records (GTask         *task,

                   gpointer       source_object,

                   gpointer       task_data,

                   GCancellable  *cancellable)

{

  LookupRecordsData *lrd = task_data;

  GList *records;

  GError *error = NULL;

#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_task_return_new_error (task, G_RESOLVER_ERROR, G_RESOLVER_ERROR_INTERNAL,

                               _("Error resolving “%s”"), lrd->rrname);

      return;

    }

#endif

  rrtype = g_resolver_record_type_to_rrtype (lrd->record_type);

  answer = g_byte_array_new ();

  for (;;)

    {

      g_byte_array_set_size (answer, len * 2);

#if defined(HAVE_RES_NQUERY)