1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
3 /* GIO - GLib Input, Output and Streaming Library
5 * Copyright (C) 2008 Red Hat, Inc.
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General
18 * Public License along with this library; if not, write to the
19 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
20 * Boston, MA 02111-1307, USA.
30 #include "gthreadedresolver.h"
31 #include "gnetworkingprivate.h"
33 #include "gcancellable.h"
34 #include "gsimpleasyncresult.h"
35 #include "gsocketaddress.h"
38 G_DEFINE_TYPE (GThreadedResolver, g_threaded_resolver, G_TYPE_RESOLVER)
40 static void threaded_resolver_thread (gpointer thread_data, gpointer pool_data);
43 g_threaded_resolver_init (GThreadedResolver *gtr)
45 if (g_thread_supported ())
46 gtr->thread_pool = g_thread_pool_new (threaded_resolver_thread, gtr,
51 finalize (GObject *object)
53 GThreadedResolver *gtr = G_THREADED_RESOLVER (object);
55 g_thread_pool_free (gtr->thread_pool, FALSE, FALSE);
57 G_OBJECT_CLASS (g_threaded_resolver_parent_class)->finalize (object);
60 /* A GThreadedResolverRequest represents a request in progress
61 * (usually, but see case 1). It is refcounted, to make sure that it
62 * doesn't get freed too soon. In particular, it can't be freed until
63 * (a) the resolver thread has finished resolving, (b) the calling
64 * thread has received an answer, and (c) no other thread could be in
65 * the process of trying to cancel it.
69 * 1. Synchronous non-cancellable request: in this case, the request
70 * is simply done in the calling thread, without using
71 * GThreadedResolverRequest at all.
73 * 2. Synchronous cancellable request: A req is created with a GCond,
74 * and 3 refs (for the resolution thread, the calling thread, and
75 * the cancellation signal handler).
77 * a. If the resolution completes successfully, the thread pool
78 * function (threaded_resolver_thread()) will call
79 * g_threaded_resolver_request_complete(), which will detach
80 * the "cancelled" signal handler (dropping one ref on req)
81 * and signal the GCond, and then unref the req. The calling
82 * thread receives the signal from the GCond, processes the
83 * response, and unrefs the req, causing it to be freed.
85 * b. If the resolution is cancelled before completing,
86 * request_cancelled() will call
87 * g_threaded_resolver_request_complete(), which will detach
88 * the signal handler (as above, unreffing the req), set
89 * req->error to indicate that it was cancelled, and signal
90 * the GCond. The calling thread receives the signal from the
91 * GCond, processes the response, and unrefs the req.
92 * Eventually, the resolver thread finishes resolving (or
93 * times out in the resolver) and calls
94 * g_threaded_resolver_request_complete() again, but
95 * _request_complete() does nothing this time since the
96 * request is already complete. The thread pool func then
97 * unrefs the req, causing it to be freed.
99 * 3. Asynchronous request: A req is created with a GSimpleAsyncResult
100 * (and no GCond). The calling thread's ref on req is set up to be
101 * automatically dropped when the async_result is freed. Two
104 * a. If the resolution completes, the thread pool function
105 * (threaded_resolver_thread()) will call
106 * g_threaded_resolver_request_complete(), which will detach
107 * the "cancelled" signal handler (if it was present)
108 * (unreffing the req), queue the async_result to complete in
109 * an idle handler, unref the async_result (which is still
110 * reffed by the idle handler though), and then unref the req.
111 * The main thread then invokes the async_result's callback
112 * and processes the response. When it finishes, the
113 * async_result drops the ref that was taken by
114 * g_simple_async_result_complete_in_idle(), which causes the
115 * async_result to be freed, which causes req to be unreffed
118 * b. If the resolution is cancelled, request_cancelled() will
119 * call g_threaded_resolver_request_complete(), which will
120 * detach the signal handler (as above, unreffing the req) set
121 * req->error to indicate that it was cancelled, and queue and
122 * unref the async_result. The main thread completes the
123 * async_request and unrefs it and the req, as above.
124 * Eventually, the resolver thread finishes resolving (or
125 * times out in the resolver) and calls
126 * g_threaded_resolver_request_complete() again, but
127 * _request_complete() does nothing this time since the
128 * request is already complete. The thread pool func then
129 * unrefs the req, causing it to be freed.
131 * g_threaded_resolver_request_complete() ensures that if the request
132 * completes and cancels "at the same time" that only one of the two
133 * conditions gets processed.
136 typedef struct _GThreadedResolverRequest GThreadedResolverRequest;
137 typedef void (*GThreadedResolverResolveFunc) (GThreadedResolverRequest *, GError **);
138 typedef void (*GThreadedResolverFreeFunc) (GThreadedResolverRequest *);
140 struct _GThreadedResolverRequest {
141 GThreadedResolverResolveFunc resolve_func;
142 GThreadedResolverFreeFunc free_func;
150 GInetAddress *address;
159 GCancellable *cancellable;
166 GSimpleAsyncResult *async_result;
171 static void g_threaded_resolver_request_unref (GThreadedResolverRequest *req);
172 static void request_cancelled (GCancellable *cancellable, gpointer req);
173 static void request_cancelled_disconnect_notify (gpointer req, GClosure *closure);
175 static GThreadedResolverRequest *
176 g_threaded_resolver_request_new (GThreadedResolverResolveFunc resolve_func,
177 GThreadedResolverFreeFunc free_func,
178 GCancellable *cancellable)
180 GThreadedResolverRequest *req;
182 req = g_slice_new0 (GThreadedResolverRequest);
183 req->resolve_func = resolve_func;
184 req->free_func = free_func;
186 /* Initial refcount is 2; one for the caller and one for resolve_func */
189 if (g_thread_supported ())
190 req->mutex = g_mutex_new ();
191 /* Initially locked; caller must unlock */
192 g_mutex_lock (req->mutex);
197 req->cancellable = g_object_ref (cancellable);
198 g_signal_connect_data (cancellable, "cancelled",
199 G_CALLBACK (request_cancelled), req,
200 request_cancelled_disconnect_notify, 0);
207 g_threaded_resolver_request_unref (GThreadedResolverRequest *req)
211 g_mutex_lock (req->mutex);
212 ref_count = --req->ref_count;
213 g_mutex_unlock (req->mutex);
217 g_mutex_free (req->mutex);
220 g_cond_free (req->cond);
223 g_error_free (req->error);
226 req->free_func (req);
228 /* We don't have to free req->cancellable or req->async_result,
229 * since (if set), they must already have been freed by
230 * request_complete() in order to get here.
233 g_slice_free (GThreadedResolverRequest, req);
237 g_threaded_resolver_request_complete (GThreadedResolverRequest *req,
240 g_mutex_lock (req->mutex);
243 /* The req was cancelled, and now it has finished resolving as
244 * well. But we have nowhere to send the result, so just return.
246 g_mutex_unlock (req->mutex);
250 req->complete = TRUE;
251 g_mutex_unlock (req->mutex);
253 if (req->cancellable)
255 /* Possibly propagate a cancellation error */
256 if (cancelled && !req->error)
257 g_cancellable_set_error_if_cancelled (req->cancellable, &req->error);
259 /* Drop the signal handler's ref on @req */
260 g_signal_handlers_disconnect_by_func (req->cancellable, request_cancelled, req);
261 g_object_unref (req->cancellable);
262 req->cancellable = NULL;
266 g_cond_signal (req->cond);
267 else if (req->async_result)
270 g_simple_async_result_set_from_error (req->async_result, req->error);
271 g_simple_async_result_complete_in_idle (req->async_result);
273 /* Drop our ref on the async_result, which will eventually cause
274 * it to drop its ref on req.
276 g_object_unref (req->async_result);
277 req->async_result = NULL;
282 request_cancelled (GCancellable *cancellable,
285 GThreadedResolverRequest *req = user_data;
287 g_threaded_resolver_request_complete (req, TRUE);
289 /* We can't actually cancel the resolver thread; it will eventually
290 * complete on its own and call request_complete() again, which will
291 * do nothing the second time.
296 request_cancelled_disconnect_notify (gpointer req,
299 g_threaded_resolver_request_unref (req);
303 threaded_resolver_thread (gpointer thread_data,
306 GThreadedResolverRequest *req = thread_data;
308 req->resolve_func (req, &req->error);
309 g_threaded_resolver_request_complete (req, FALSE);
310 g_threaded_resolver_request_unref (req);
314 resolve_sync (GThreadedResolver *gtr,
315 GThreadedResolverRequest *req,
318 if (!req->cancellable || !gtr->thread_pool)
320 req->resolve_func (req, error);
321 g_mutex_unlock (req->mutex);
323 g_threaded_resolver_request_complete (req, FALSE);
324 g_threaded_resolver_request_unref (req);
328 req->cond = g_cond_new ();
329 g_thread_pool_push (gtr->thread_pool, req, NULL);
330 g_cond_wait (req->cond, req->mutex);
331 g_mutex_unlock (req->mutex);
335 g_propagate_error (error, req->error);
341 resolve_async (GThreadedResolver *gtr,
342 GThreadedResolverRequest *req,
343 GAsyncReadyCallback callback,
347 req->async_result = g_simple_async_result_new (G_OBJECT (gtr),
348 callback, user_data, tag);
349 g_simple_async_result_set_op_res_gpointer (req->async_result, req,
350 (GDestroyNotify)g_threaded_resolver_request_unref);
351 g_thread_pool_push (gtr->thread_pool, req, NULL);
352 g_mutex_unlock (req->mutex);
355 static GThreadedResolverRequest *
356 resolve_finish (GResolver *resolver,
357 GAsyncResult *result,
361 g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (resolver), tag), NULL);
363 return g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
367 do_lookup_by_name (GThreadedResolverRequest *req,
370 struct addrinfo *res = NULL;
373 retval = getaddrinfo (req->u.name.hostname, NULL,
374 &_g_resolver_addrinfo_hints, &res);
375 req->u.name.addresses =
376 _g_resolver_addresses_from_addrinfo (req->u.name.hostname, res, retval, error);
382 lookup_by_name (GResolver *resolver,
383 const gchar *hostname,
384 GCancellable *cancellable,
387 GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
388 GThreadedResolverRequest *req;
391 req = g_threaded_resolver_request_new (do_lookup_by_name, NULL, cancellable);
392 req->u.name.hostname = (gchar *)hostname;
393 resolve_sync (gtr, req, error);
395 addresses = req->u.name.addresses;
396 g_threaded_resolver_request_unref (req);
401 free_lookup_by_name (GThreadedResolverRequest *req)
403 g_free (req->u.name.hostname);
404 if (req->u.name.addresses)
405 g_resolver_free_addresses (req->u.name.addresses);
409 lookup_by_name_async (GResolver *resolver,
410 const gchar *hostname,
411 GCancellable *cancellable,
412 GAsyncReadyCallback callback,
415 GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
416 GThreadedResolverRequest *req;
418 req = g_threaded_resolver_request_new (do_lookup_by_name, free_lookup_by_name,
420 req->u.name.hostname = g_strdup (hostname);
421 resolve_async (gtr, req, callback, user_data, lookup_by_name_async);
425 lookup_by_name_finish (GResolver *resolver,
426 GAsyncResult *result,
429 GThreadedResolverRequest *req;
432 req = resolve_finish (resolver, result, lookup_by_name_async, error);
433 addresses = req->u.name.addresses;
434 req->u.name.addresses = NULL;
440 do_lookup_by_address (GThreadedResolverRequest *req,
443 struct sockaddr_storage sockaddr;
445 gchar name[NI_MAXHOST];
448 _g_resolver_address_to_sockaddr (req->u.address.address,
449 &sockaddr, &sockaddr_size);
451 retval = getnameinfo ((struct sockaddr *)&sockaddr, sockaddr_size,
452 name, sizeof (name), NULL, 0, NI_NAMEREQD);
453 req->u.address.name = _g_resolver_name_from_nameinfo (req->u.address.address,
454 name, retval, error);
458 lookup_by_address (GResolver *resolver,
459 GInetAddress *address,
460 GCancellable *cancellable,
463 GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
464 GThreadedResolverRequest *req;
467 req = g_threaded_resolver_request_new (do_lookup_by_address, NULL, cancellable);
468 req->u.address.address = address;
469 resolve_sync (gtr, req, error);
471 name = req->u.address.name;
472 g_threaded_resolver_request_unref (req);
477 free_lookup_by_address (GThreadedResolverRequest *req)
479 g_object_unref (req->u.address.address);
480 if (req->u.address.name)
481 g_free (req->u.address.name);
485 lookup_by_address_async (GResolver *resolver,
486 GInetAddress *address,
487 GCancellable *cancellable,
488 GAsyncReadyCallback callback,
491 GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
492 GThreadedResolverRequest *req;
494 req = g_threaded_resolver_request_new (do_lookup_by_address,
495 free_lookup_by_address,
497 req->u.address.address = g_object_ref (address);
498 resolve_async (gtr, req, callback, user_data, lookup_by_address_async);
502 lookup_by_address_finish (GResolver *resolver,
503 GAsyncResult *result,
506 GThreadedResolverRequest *req;
509 req = resolve_finish (resolver, result, lookup_by_address_async, error);
510 name = req->u.address.name;
511 req->u.address.name = NULL;
517 do_lookup_service (GThreadedResolverRequest *req,
520 #if defined(G_OS_UNIX)
523 #elif defined(G_OS_WIN32)
528 #if defined(G_OS_UNIX)
529 len = res_query (req->u.service.rrname, C_IN, T_SRV, answer, sizeof (answer));
531 req->u.service.targets = _g_resolver_targets_from_res_query (req->u.service.rrname, answer, len, herr, error);
532 #elif defined(G_OS_WIN32)
533 status = DnsQuery_A (req->u.service.rrname, DNS_TYPE_SRV,
534 DNS_QUERY_STANDARD, NULL, &results, NULL);
535 req->u.service.targets = _g_resolver_targets_from_DnsQuery (req->u.service.rrname, status, results, error);
536 DnsRecordListFree (results, DnsFreeRecordList);
541 lookup_service (GResolver *resolver,
543 GCancellable *cancellable,
546 GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
547 GThreadedResolverRequest *req;
550 req = g_threaded_resolver_request_new (do_lookup_service, NULL, cancellable);
551 req->u.service.rrname = (char *)rrname;
552 resolve_sync (gtr, req, error);
554 targets = req->u.service.targets;
555 g_threaded_resolver_request_unref (req);
560 free_lookup_service (GThreadedResolverRequest *req)
562 g_free (req->u.service.rrname);
563 if (req->u.service.targets)
564 g_resolver_free_targets (req->u.service.targets);
568 lookup_service_async (GResolver *resolver,
570 GCancellable *cancellable,
571 GAsyncReadyCallback callback,
574 GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
575 GThreadedResolverRequest *req;
577 req = g_threaded_resolver_request_new (do_lookup_service,
580 req->u.service.rrname = g_strdup (rrname);
581 resolve_async (gtr, req, callback, user_data, lookup_service_async);
585 lookup_service_finish (GResolver *resolver,
586 GAsyncResult *result,
589 GThreadedResolverRequest *req;
592 req = resolve_finish (resolver, result, lookup_service_async, error);
593 targets = req->u.service.targets;
594 req->u.service.targets = NULL;
600 g_threaded_resolver_class_init (GThreadedResolverClass *threaded_class)
602 GResolverClass *resolver_class = G_RESOLVER_CLASS (threaded_class);
603 GObjectClass *object_class = G_OBJECT_CLASS (threaded_class);
605 resolver_class->lookup_by_name = lookup_by_name;
606 resolver_class->lookup_by_name_async = lookup_by_name_async;
607 resolver_class->lookup_by_name_finish = lookup_by_name_finish;
608 resolver_class->lookup_by_address = lookup_by_address;
609 resolver_class->lookup_by_address_async = lookup_by_address_async;
610 resolver_class->lookup_by_address_finish = lookup_by_address_finish;
611 resolver_class->lookup_service = lookup_service;
612 resolver_class->lookup_service_async = lookup_service_async;
613 resolver_class->lookup_service_finish = lookup_service_finish;
615 object_class->finalize = finalize;