luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-11-09 19:06:15 +01:00
Code Issues Packages Projects Releases Wiki Activity
ebdfcf15bf
glib/gio/gthreadedresolver.c
Andy Holmes da3510575e
gthreadedresolver: ref-sink returned records in lookup_records() 
The return value to `lookup_records()` methods is set as `transfer full`
but the code path in `g_resolver_records_from_res_query()` doesn't
sink the GVariant.

Add the `g_variant_ref_sink()` call when prepending the record, so
the list hold a full reference on each records.

closes #3393
2024-07-04 12:06:12 -07:00

1678 lines
52 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* -*- 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 ("Unrecognized DNS record type %u", rrtype);
record = NULL;
break;
}
if (record != NULL)
records = g_list_prepend (records, g_variant_ref_sink (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;
}
Reference in New Issue View Git Blame Copy Permalink