luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-11-05 08:56:16 +01:00
Code Issues Packages Projects Releases Wiki Activity
716ec71ece
glib/gio/gthreadedresolver.c

944 lines
26 KiB
C
Raw Blame History

/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/* GIO - GLib Input, Output and Streaming Library
*
* Copyright (C) 2008 Red Hat, Inc.
*
* 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 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, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*/
#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;
}
}
static struct addrinfo addrinfo_hints;
static void
do_lookup_by_name (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
const char *hostname = task_data;
struct addrinfo *res = NULL;
GList *addresses;
gint retval;
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 || !G_IS_INET_SOCKET_ADDRESS (sockaddr))
continue;
addr = g_object_ref (g_inet_socket_address_get_address ((GInetSocketAddress *)sockaddr));
addresses = g_list_prepend (addresses, addr);
g_object_unref (sockaddr);
}
addresses = g_list_reverse (addresses);
g_task_return_pointer (task, addresses,
(GDestroyNotify)g_resolver_free_addresses);
}
else
{
g_task_return_new_error (task,
G_RESOLVER_ERROR,
g_resolver_error_from_addrinfo_error (retval),
_("Error resolving '%s': %s"),
hostname, gai_strerror (retval));
}
if (res)
freeaddrinfo (res);
}
static GList *
lookup_by_name (GResolver *resolver,
const gchar *hostname,
GCancellable *cancellable,
GError **error)
{
GTask *task;
GList *addresses;
task = g_task_new (resolver, cancellable, NULL, NULL);
g_task_set_task_data (task, g_strdup (hostname), g_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_async (GResolver *resolver,
const gchar *hostname,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
task = g_task_new (resolver, cancellable, callback, user_data);
g_task_set_task_data (task, g_strdup (hostname), g_free);
g_task_set_return_on_cancel (task, TRUE);
g_task_run_in_thread (task, do_lookup_by_name);
g_object_unref (task);
}
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 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;
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)",
gai_strerror (retval));
g_free (phys);
}
}
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_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_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)
#ifdef __BIONIC__
/* 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; /* authoritive 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; /* authoritive 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 (experimentatl) */
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 > at - end)
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;
guint32 ttl;
HEADER *header;
GList *records;
GVariant *record;
if (len <= 0)
{
GResolverError errnum;
const gchar *format;
if (len == 0 || herr == HOST_NOT_FOUND || herr == NO_DATA)
{
errnum = G_RESOLVER_ERROR_NOT_FOUND;
format = _("No DNS record of the requested type for '%s'");
}
else if (herr == TRY_AGAIN)
{
errnum = G_RESOLVER_ERROR_TEMPORARY_FAILURE;
format = _("Temporarily unable to resolve '%s'");
}
else
{
errnum = G_RESOLVER_ERROR_INTERNAL;
format = _("Error resolving '%s'");
}
g_set_error (error, G_RESOLVER_ERROR, errnum, format, 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);
GETLONG (ttl, p);
ttl = ttl; /* To avoid -Wunused-but-set-variable */
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)
{
GResolverError errnum;
const gchar *format;
if (status == DNS_ERROR_RCODE_NAME_ERROR)
{
errnum = G_RESOLVER_ERROR_NOT_FOUND;
format = _("No DNS record of the requested type for '%s'");
}
else if (status == DNS_ERROR_RCODE_SERVER_FAILURE)
{
errnum = G_RESOLVER_ERROR_TEMPORARY_FAILURE;
format = _("Temporarily unable to resolve '%s'");
}
else
{
errnum = G_RESOLVER_ERROR_INTERNAL;
format = _("Error resolving '%s'");
}
g_set_error (error, G_RESOLVER_ERROR, errnum, format, 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__
#define C_IN 1
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;
rrtype = g_resolver_record_type_to_rrtype (lrd->record_type);
answer = g_byte_array_new ();
for (;;)
{
g_byte_array_set_size (answer, len * 2);
len = res_query (lrd->rrname, C_IN, rrtype, answer->data, answer->len);
/* 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 (lrd->rrname, rrtype, answer->data, len, herr, &error);
g_byte_array_free (answer, TRUE);
#else
DNS_STATUS status;
DNS_RECORD *results = NULL;
WORD dnstype;
dnstype = g_resolver_record_type_to_dnstype (lrd->record_type);
status = DnsQuery_A (lrd->rrname, dnstype, DNS_QUERY_STANDARD, NULL, &results, NULL);
records = g_resolver_records_from_DnsQuery (lrd->rrname, dnstype, status, results, &error);
if (results != NULL)
DnsRecordListFree (results, DnsFreeRecordList);
#endif
if (records)
g_task_return_pointer (task, records, (GDestroyNotify) free_records);
else
g_task_return_error (task, error);
}
static GList *
lookup_records (GResolver *resolver,
const gchar *rrname,
GResolverRecordType record_type,
GCancellable *cancellable,
GError **error)
{
GTask *task;
GList *records;
LookupRecordsData *lrd;
task = g_task_new (resolver, cancellable, NULL, NULL);
lrd = g_slice_new (LookupRecordsData);
lrd->rrname = g_strdup (rrname);
lrd->record_type = record_type;
g_task_set_task_data (task, lrd, (GDestroyNotify) free_lookup_records_data);
g_task_set_return_on_cancel (task, TRUE);
g_task_run_in_thread_sync (task, do_lookup_records);
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)
{
GTask *task;
LookupRecordsData *lrd;
task = g_task_new (resolver, cancellable, callback, user_data);
lrd = g_slice_new (LookupRecordsData);
lrd->rrname = g_strdup (rrname);
lrd->record_type = record_type;
g_task_set_task_data (task, lrd, (GDestroyNotify) free_lookup_records_data);
g_task_set_return_on_cancel (task, TRUE);
g_task_run_in_thread (task, do_lookup_records);
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);
}
static void
g_threaded_resolver_class_init (GThreadedResolverClass *threaded_class)
{
GResolverClass *resolver_class = G_RESOLVER_CLASS (threaded_class);
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_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;
/* Initialize _g_resolver_addrinfo_hints */
#ifdef AI_ADDRCONFIG
addrinfo_hints.ai_flags |= AI_ADDRCONFIG;
#endif
/* These two 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;
}
Reference in New Issue View Git Blame Copy Permalink