* 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.
+ * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "gnetworkingprivate.h"
#include "gcancellable.h"
-#include "gsimpleasyncresult.h"
+#include "ginetaddress.h"
+#include "ginetsocketaddress.h"
+#include "gtask.h"
#include "gsocketaddress.h"
+#include "gsrvtarget.h"
-#include "gioalias.h"
G_DEFINE_TYPE (GThreadedResolver, g_threaded_resolver, G_TYPE_RESOLVER)
-static void threaded_resolver_thread (gpointer thread_data, gpointer pool_data);
-
static void
g_threaded_resolver_init (GThreadedResolver *gtr)
{
- if (g_thread_supported ())
- gtr->thread_pool = g_thread_pool_new (threaded_resolver_thread, gtr,
- -1, FALSE, NULL);
-}
-
-static void
-finalize (GObject *object)
-{
- GThreadedResolver *gtr = G_THREADED_RESOLVER (object);
-
- g_thread_pool_free (gtr->thread_pool, FALSE, FALSE);
-
- G_OBJECT_CLASS (g_threaded_resolver_parent_class)->finalize (object);
-}
-
-/* A GThreadedResolverRequest represents a request in progress
- * (usually, but see case 1). It is refcounted, to make sure that it
- * doesn't get freed too soon. In particular, it can't be freed until
- * (a) the resolver thread has finished resolving, (b) the calling
- * thread has received an answer, and (c) no other thread could be in
- * the process of trying to cancel it.
- *
- * The possibilities:
- *
- * 1. Synchronous non-cancellable request: in this case, the request
- * is simply done in the calling thread, without using
- * GThreadedResolverRequest at all.
- *
- * 2. Synchronous cancellable request: A req is created with a GCond,
- * and 3 refs (for the resolution thread, the calling thread, and
- * the cancellation signal handler).
- *
- * a. If the resolution completes successfully, the thread pool
- * function (threaded_resolver_thread()) will call
- * g_threaded_resolver_request_complete(), which will detach
- * the "cancelled" signal handler (dropping one ref on req)
- * and signal the GCond, and then unref the req. The calling
- * thread receives the signal from the GCond, processes the
- * response, and unrefs the req, causing it to be freed.
- *
- * b. If the resolution is cancelled before completing,
- * request_cancelled() will call
- * g_threaded_resolver_request_complete(), which will detach
- * the signal handler (as above, unreffing the req), set
- * req->error to indicate that it was cancelled, and signal
- * the GCond. The calling thread receives the signal from the
- * GCond, processes the response, and unrefs the req.
- * Eventually, the resolver thread finishes resolving (or
- * times out in the resolver) and calls
- * g_threaded_resolver_request_complete() again, but
- * _request_complete() does nothing this time since the
- * request is already complete. The thread pool func then
- * unrefs the req, causing it to be freed.
- *
- * 3. Asynchronous request: A req is created with a GSimpleAsyncResult
- * (and no GCond). The calling thread's ref on req is set up to be
- * automatically dropped when the async_result is freed. Two
- * sub-possibilities:
- *
- * a. If the resolution completes, the thread pool function
- * (threaded_resolver_thread()) will call
- * g_threaded_resolver_request_complete(), which will detach
- * the "cancelled" signal handler (if it was present)
- * (unreffing the req), queue the async_result to complete in
- * an idle handler, unref the async_result (which is still
- * reffed by the idle handler though), and then unref the req.
- * The main thread then invokes the async_result's callback
- * and processes the response. When it finishes, the
- * async_result drops the ref that was taken by
- * g_simple_async_result_complete_in_idle(), which causes the
- * async_result to be freed, which causes req to be unreffed
- * and freed.
- *
- * b. If the resolution is cancelled, request_cancelled() will
- * call g_threaded_resolver_request_complete(), which will
- * detach the signal handler (as above, unreffing the req) set
- * req->error to indicate that it was cancelled, and queue and
- * unref the async_result. The main thread completes the
- * async_request and unrefs it and the req, as above.
- * Eventually, the resolver thread finishes resolving (or
- * times out in the resolver) and calls
- * g_threaded_resolver_request_complete() again, but
- * _request_complete() does nothing this time since the
- * request is already complete. The thread pool func then
- * unrefs the req, causing it to be freed.
- *
- * g_threaded_resolver_request_complete() ensures that if the request
- * completes and cancels "at the same time" that only one of the two
- * conditions gets processed.
- */
-
-typedef struct _GThreadedResolverRequest GThreadedResolverRequest;
-typedef void (*GThreadedResolverResolveFunc) (GThreadedResolverRequest *, GError **);
-typedef void (*GThreadedResolverFreeFunc) (GThreadedResolverRequest *);
-
-struct _GThreadedResolverRequest {
- GThreadedResolverResolveFunc resolve_func;
- GThreadedResolverFreeFunc free_func;
-
- union {
- struct {
- gchar *hostname;
- GList *addresses;
- } name;
- struct {
- GInetAddress *address;
- gchar *name;
- } address;
- struct {
- gchar *rrname;
- GList *targets;
- } service;
- } u;
-
- GCancellable *cancellable;
- GError *error;
-
- GMutex *mutex;
- guint ref_count;
-
- GCond *cond;
- GSimpleAsyncResult *async_result;
- gboolean complete;
-
-};
-
-static void g_threaded_resolver_request_unref (GThreadedResolverRequest *req);
-static void request_cancelled (GCancellable *cancellable, gpointer req);
-static void request_cancelled_disconnect_notify (gpointer req, GClosure *closure);
-
-static GThreadedResolverRequest *
-g_threaded_resolver_request_new (GThreadedResolverResolveFunc resolve_func,
- GThreadedResolverFreeFunc free_func,
- GCancellable *cancellable)
-{
- GThreadedResolverRequest *req;
-
- req = g_slice_new0 (GThreadedResolverRequest);
- req->resolve_func = resolve_func;
- req->free_func = free_func;
-
- /* Initial refcount is 2; one for the caller and one for resolve_func */
- req->ref_count = 2;
-
- if (g_thread_supported ())
- req->mutex = g_mutex_new ();
- /* Initially locked; caller must unlock */
- g_mutex_lock (req->mutex);
-
- if (cancellable)
- {
- req->ref_count++;
- req->cancellable = g_object_ref (cancellable);
- g_signal_connect_data (cancellable, "cancelled",
- G_CALLBACK (request_cancelled), req,
- request_cancelled_disconnect_notify, 0);
- }
-
- return req;
-}
-
-static void
-g_threaded_resolver_request_unref (GThreadedResolverRequest *req)
-{
- guint ref_count;
-
- g_mutex_lock (req->mutex);
- ref_count = --req->ref_count;
- g_mutex_unlock (req->mutex);
- if (ref_count > 0)
- return;
-
- g_mutex_free (req->mutex);
-
- if (req->cond)
- g_cond_free (req->cond);
-
- if (req->error)
- g_error_free (req->error);
-
- if (req->free_func)
- req->free_func (req);
-
- /* We don't have to free req->cancellable or req->async_result,
- * since (if set), they must already have been freed by
- * request_complete() in order to get here.
- */
-
- g_slice_free (GThreadedResolverRequest, req);
}
-static void
-g_threaded_resolver_request_complete (GThreadedResolverRequest *req,
- gboolean cancelled)
+static GResolverError
+g_resolver_error_from_addrinfo_error (gint err)
{
- g_mutex_lock (req->mutex);
- if (req->complete)
- {
- /* The req was cancelled, and now it has finished resolving as
- * well. But we have nowhere to send the result, so just return.
- */
- g_mutex_unlock (req->mutex);
- return;
- }
-
- req->complete = TRUE;
- g_mutex_unlock (req->mutex);
-
- if (req->cancellable)
+ switch (err)
{
- /* Possibly propagate a cancellation error */
- if (cancelled && !req->error)
- g_cancellable_set_error_if_cancelled (req->cancellable, &req->error);
-
- /* Drop the signal handler's ref on @req */
- g_signal_handlers_disconnect_by_func (req->cancellable, request_cancelled, req);
- g_object_unref (req->cancellable);
- req->cancellable = NULL;
- }
+ case EAI_FAIL:
+#if defined(EAI_NODATA) && (EAI_NODATA != EAI_NONAME)
+ case EAI_NODATA:
+#endif
+ case EAI_NONAME:
+ return G_RESOLVER_ERROR_NOT_FOUND;
- if (req->cond)
- g_cond_signal (req->cond);
- else if (req->async_result)
- {
- if (req->error)
- g_simple_async_result_set_from_error (req->async_result, req->error);
- g_simple_async_result_complete_in_idle (req->async_result);
+ case EAI_AGAIN:
+ return G_RESOLVER_ERROR_TEMPORARY_FAILURE;
- /* Drop our ref on the async_result, which will eventually cause
- * it to drop its ref on req.
- */
- g_object_unref (req->async_result);
- req->async_result = NULL;
+ default:
+ return G_RESOLVER_ERROR_INTERNAL;
}
}
-static void
-request_cancelled (GCancellable *cancellable,
- gpointer user_data)
-{
- GThreadedResolverRequest *req = user_data;
-
- g_threaded_resolver_request_complete (req, TRUE);
-
- /* We can't actually cancel the resolver thread; it will eventually
- * complete on its own and call request_complete() again, which will
- * do nothing the second time.
- */
-}
-
-static void
-request_cancelled_disconnect_notify (gpointer req,
- GClosure *closure)
-{
- g_threaded_resolver_request_unref (req);
-}
+static struct addrinfo addrinfo_hints;
static void
-threaded_resolver_thread (gpointer thread_data,
- gpointer pool_data)
+do_lookup_by_name (GTask *task,
+ gpointer source_object,
+ gpointer task_data,
+ GCancellable *cancellable)
{
- GThreadedResolverRequest *req = thread_data;
+ const char *hostname = task_data;
+ struct addrinfo *res = NULL;
+ GList *addresses;
+ gint retval;
- req->resolve_func (req, &req->error);
- g_threaded_resolver_request_complete (req, FALSE);
- g_threaded_resolver_request_unref (req);
-}
+ retval = getaddrinfo (hostname, NULL, &addrinfo_hints, &res);
-static void
-resolve_sync (GThreadedResolver *gtr,
- GThreadedResolverRequest *req,
- GError **error)
-{
- if (!req->cancellable || !gtr->thread_pool)
+ if (retval == 0)
{
- req->resolve_func (req, error);
- g_mutex_unlock (req->mutex);
- return;
+ 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"));
+ }
}
-
- req->cond = g_cond_new ();
- g_thread_pool_push (gtr->thread_pool, req, NULL);
- g_cond_wait (req->cond, req->mutex);
- g_mutex_unlock (req->mutex);
-
- if (req->error)
+ else
{
- g_propagate_error (error, req->error);
- req->error = NULL;
+ g_task_return_new_error (task,
+ G_RESOLVER_ERROR,
+ g_resolver_error_from_addrinfo_error (retval),
+ _("Error resolving '%s': %s"),
+ hostname, gai_strerror (retval));
}
-}
-
-static void
-resolve_async (GThreadedResolver *gtr,
- GThreadedResolverRequest *req,
- GAsyncReadyCallback callback,
- gpointer user_data,
- gpointer tag)
-{
- req->async_result = g_simple_async_result_new (G_OBJECT (gtr),
- callback, user_data, tag);
- g_simple_async_result_set_op_res_gpointer (req->async_result, req, NULL);
- g_thread_pool_push (gtr->thread_pool, req, NULL);
- g_mutex_unlock (req->mutex);
-}
-
-static GThreadedResolverRequest *
-resolve_finish (GResolver *resolver,
- GAsyncResult *result,
- gpointer tag,
- GError **error)
-{
- g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (resolver), tag), NULL);
-
- return g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
-}
-static void
-do_lookup_by_name (GThreadedResolverRequest *req,
- GError **error)
-{
- struct addrinfo *res = NULL;
- gint retval;
-
- retval = getaddrinfo (req->u.name.hostname, NULL,
- &_g_resolver_addrinfo_hints, &res);
- req->u.name.addresses =
- _g_resolver_addresses_from_addrinfo (req->u.name.hostname, res, retval, error);
if (res)
freeaddrinfo (res);
}
GCancellable *cancellable,
GError **error)
{
- GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
- GThreadedResolverRequest *req;
+ GTask *task;
GList *addresses;
- req = g_threaded_resolver_request_new (do_lookup_by_name, NULL, cancellable);
- req->u.name.hostname = (gchar *)hostname;
- resolve_sync (gtr, req, error);
+ 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);
- addresses = req->u.name.addresses;
- g_threaded_resolver_request_unref (req);
return addresses;
}
static void
-free_lookup_by_name (GThreadedResolverRequest *req)
-{
- g_free (req->u.name.hostname);
- if (req->u.name.addresses)
- g_resolver_free_addresses (req->u.name.addresses);
-}
-
-static void
lookup_by_name_async (GResolver *resolver,
const gchar *hostname,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
- GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
- GThreadedResolverRequest *req;
+ GTask *task;
- req = g_threaded_resolver_request_new (do_lookup_by_name, free_lookup_by_name,
- cancellable);
- req->u.name.hostname = g_strdup (hostname);
- resolve_async (gtr, req, callback, user_data, lookup_by_name_async);
+ 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 *
GAsyncResult *result,
GError **error)
{
- GThreadedResolverRequest *req;
- GList *addresses;
+ g_return_val_if_fail (g_task_is_valid (result, resolver), NULL);
- req = resolve_finish (resolver, result, lookup_by_name_async, error);
- addresses = req->u.name.addresses;
- req->u.name.addresses = NULL;
- return addresses;
+ return g_task_propagate_pointer (G_TASK (result), error);
}
static void
-do_lookup_by_address (GThreadedResolverRequest *req,
- GError **error)
+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;
- _g_resolver_address_to_sockaddr (req->u.address.address,
- &sockaddr, &sockaddr_size);
+ 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);
- req->u.address.name = _g_resolver_name_from_nameinfo (req->u.address.address,
- name, retval, error);
+ 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 *
GCancellable *cancellable,
GError **error)
{
- GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
- GThreadedResolverRequest *req;
+ GTask *task;
gchar *name;
- req = g_threaded_resolver_request_new (do_lookup_by_address, NULL, cancellable);
- req->u.address.address = address;
- resolve_sync (gtr, req, error);
+ 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);
- name = req->u.address.name;
- g_threaded_resolver_request_unref (req);
return name;
}
static void
-free_lookup_by_address (GThreadedResolverRequest *req)
-{
- g_object_unref (req->u.address.address);
- if (req->u.address.name)
- g_free (req->u.address.name);
-}
-
-static void
lookup_by_address_async (GResolver *resolver,
GInetAddress *address,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
- GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
- GThreadedResolverRequest *req;
-
- req = g_threaded_resolver_request_new (do_lookup_by_address,
- free_lookup_by_address,
- cancellable);
- req->u.address.address = g_object_ref (address);
- resolve_async (gtr, req, callback, user_data, lookup_by_address_async);
+ 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 *
GAsyncResult *result,
GError **error)
{
- GThreadedResolverRequest *req;
- gchar *name;
+ g_return_val_if_fail (g_task_is_valid (result, resolver), NULL);
- req = resolve_finish (resolver, result, lookup_by_address_async, error);
- name = req->u.address.name;
- req->u.address.name = NULL;
- return name;
+ 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)
+ {
+ 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);
+ 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)
+ {
+ 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
-do_lookup_service (GThreadedResolverRequest *req,
- GError **error)
+free_records (GList *records)
{
+ g_list_free_full (records, (GDestroyNotify) g_variant_unref);
+}
+
#if defined(G_OS_UNIX)
- gint len, herr;
- guchar answer[1024];
-#elif defined(G_OS_WIN32)
- DNS_STATUS status;
- DNS_RECORD *results;
+#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)
- len = res_query (req->u.service.rrname, C_IN, T_SRV, answer, sizeof (answer));
+ 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;
- req->u.service.targets = _g_resolver_targets_from_res_query (req->u.service.rrname, answer, len, herr, error);
-#elif defined(G_OS_WIN32)
- status = DnsQuery_A (req->u.service.rrname, DNS_TYPE_SRV,
- DNS_QUERY_STANDARD, NULL, &results, NULL);
- req->u.service.targets = _g_resolver_targets_from_DnsQuery (req->u.service.rrname, status, results, error);
- DnsRecordListFree (results, DnsFreeRecordList);
+ 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_service (GResolver *resolver,
- const gchar *rrname,
- GCancellable *cancellable,
- GError **error)
+lookup_records (GResolver *resolver,
+ const gchar *rrname,
+ GResolverRecordType record_type,
+ GCancellable *cancellable,
+ GError **error)
{
- GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
- GThreadedResolverRequest *req;
- GList *targets;
+ GTask *task;
+ GList *records;
+ LookupRecordsData *lrd;
- req = g_threaded_resolver_request_new (do_lookup_service, NULL, cancellable);
- req->u.service.rrname = (char *)rrname;
- resolve_sync (gtr, req, error);
+ task = g_task_new (resolver, cancellable, NULL, NULL);
- targets = req->u.service.targets;
- g_threaded_resolver_request_unref (req);
- return targets;
-}
+ 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);
-static void
-free_lookup_service (GThreadedResolverRequest *req)
-{
- g_free (req->u.service.rrname);
- if (req->u.service.targets)
- g_resolver_free_targets (req->u.service.targets);
+ 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_service_async (GResolver *resolver,
+lookup_records_async (GResolver *resolver,
const char *rrname,
- GCancellable *cancellable,
+ GResolverRecordType record_type,
+ GCancellable *cancellable,
GAsyncReadyCallback callback,
- gpointer user_data)
+ gpointer user_data)
{
- GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
- GThreadedResolverRequest *req;
-
- req = g_threaded_resolver_request_new (do_lookup_service,
- free_lookup_service,
- cancellable);
- req->u.service.rrname = g_strdup (rrname);
- resolve_async (gtr, req, callback, user_data, lookup_service_async);
+ 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_service_finish (GResolver *resolver,
+lookup_records_finish (GResolver *resolver,
GAsyncResult *result,
- GError **error)
+ GError **error)
{
- GThreadedResolverRequest *req;
- GList *targets;
+ g_return_val_if_fail (g_task_is_valid (result, resolver), NULL);
- req = resolve_finish (resolver, result, lookup_service_async, error);
- targets = req->u.service.targets;
- req->u.service.targets = NULL;
- return targets;
+ return g_task_propagate_pointer (G_TASK (result), error);
}
g_threaded_resolver_class_init (GThreadedResolverClass *threaded_class)
{
GResolverClass *resolver_class = G_RESOLVER_CLASS (threaded_class);
- GObjectClass *object_class = G_OBJECT_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_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_service = lookup_service;
- resolver_class->lookup_service_async = lookup_service_async;
- resolver_class->lookup_service_finish = lookup_service_finish;
+ resolver_class->lookup_records = lookup_records;
+ resolver_class->lookup_records_async = lookup_records_async;
+ resolver_class->lookup_records_finish = lookup_records_finish;
- object_class->finalize = finalize;
+ /* Initialize 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;
}
-
-#define __G_THREADED_RESOLVER_C__
-#include "gioaliasdef.c"
projects / platform / upstream / glib.git / blobdiff