/* -*- 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 #include "glibintl.h" #include #include #include "gthreadedresolver.h" #include "gnetworkingprivate.h" #include "gcancellable.h" #include "gsimpleasyncresult.h" #include "gsocketaddress.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) { 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) { /* 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; } 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); /* 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; } } 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 void threaded_resolver_thread (gpointer thread_data, gpointer pool_data) { GThreadedResolverRequest *req = thread_data; req->resolve_func (req, &req->error); g_threaded_resolver_request_complete (req, FALSE); g_threaded_resolver_request_unref (req); } static void resolve_sync (GThreadedResolver *gtr, GThreadedResolverRequest *req, GError **error) { if (!req->cancellable || !gtr->thread_pool) { req->resolve_func (req, error); g_mutex_unlock (req->mutex); g_threaded_resolver_request_complete (req, FALSE); g_threaded_resolver_request_unref (req); return; } 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) { g_propagate_error (error, req->error); req->error = NULL; } } 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, (GDestroyNotify)g_threaded_resolver_request_unref); 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); } static GList * lookup_by_name (GResolver *resolver, const gchar *hostname, GCancellable *cancellable, GError **error) { GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver); GThreadedResolverRequest *req; 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); 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; 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); } static GList * lookup_by_name_finish (GResolver *resolver, GAsyncResult *result, GError **error) { GThreadedResolverRequest *req; GList *addresses; req = resolve_finish (resolver, result, lookup_by_name_async, error); addresses = req->u.name.addresses; req->u.name.addresses = NULL; return addresses; } static void do_lookup_by_address (GThreadedResolverRequest *req, GError **error) { struct sockaddr_storage sockaddr; gsize sockaddr_size; gchar name[NI_MAXHOST]; gint retval; _g_resolver_address_to_sockaddr (req->u.address.address, &sockaddr, &sockaddr_size); 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); } static gchar * lookup_by_address (GResolver *resolver, GInetAddress *address, GCancellable *cancellable, GError **error) { GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver); GThreadedResolverRequest *req; gchar *name; req = g_threaded_resolver_request_new (do_lookup_by_address, NULL, cancellable); req->u.address.address = address; resolve_sync (gtr, req, error); 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); } static gchar * lookup_by_address_finish (GResolver *resolver, GAsyncResult *result, GError **error) { GThreadedResolverRequest *req; gchar *name; req = resolve_finish (resolver, result, lookup_by_address_async, error); name = req->u.address.name; req->u.address.name = NULL; return name; } static void do_lookup_service (GThreadedResolverRequest *req, GError **error) { #if defined(G_OS_UNIX) gint len, herr; guchar answer[1024]; #elif defined(G_OS_WIN32) DNS_STATUS status; DNS_RECORD *results; #endif #if defined(G_OS_UNIX) len = res_query (req->u.service.rrname, C_IN, T_SRV, answer, sizeof (answer)); 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); #endif } static GList * lookup_service (GResolver *resolver, const gchar *rrname, GCancellable *cancellable, GError **error) { GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver); GThreadedResolverRequest *req; GList *targets; req = g_threaded_resolver_request_new (do_lookup_service, NULL, cancellable); req->u.service.rrname = (char *)rrname; resolve_sync (gtr, req, error); targets = req->u.service.targets; g_threaded_resolver_request_unref (req); return targets; } 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); } static void lookup_service_async (GResolver *resolver, const char *rrname, GCancellable *cancellable, GAsyncReadyCallback callback, 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); } static GList * lookup_service_finish (GResolver *resolver, GAsyncResult *result, GError **error) { GThreadedResolverRequest *req; GList *targets; req = resolve_finish (resolver, result, lookup_service_async, error); targets = req->u.service.targets; req->u.service.targets = NULL; return targets; } static void 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_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_service = lookup_service; resolver_class->lookup_service_async = lookup_service_async; resolver_class->lookup_service_finish = lookup_service_finish; object_class->finalize = finalize; } #define __G_THREADED_RESOLVER_C__ #include "gioaliasdef.c"