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 gtr
->thread_pool
= g_thread_pool_new (threaded_resolver_thread
, gtr
,
50 finalize (GObject
*object
)
52 GThreadedResolver
*gtr
= G_THREADED_RESOLVER (object
);
54 g_thread_pool_free (gtr
->thread_pool
, FALSE
, FALSE
);
56 G_OBJECT_CLASS (g_threaded_resolver_parent_class
)->finalize (object
);
59 /* A GThreadedResolverRequest represents a request in progress
60 * (usually, but see case 1). It is refcounted, to make sure that it
61 * doesn't get freed too soon. In particular, it can't be freed until
62 * (a) the resolver thread has finished resolving, (b) the calling
63 * thread has received an answer, and (c) no other thread could be in
64 * the process of trying to cancel it.
68 * 1. Synchronous non-cancellable request: in this case, the request
69 * is simply done in the calling thread, without using
70 * GThreadedResolverRequest at all.
72 * 2. Synchronous cancellable request: A req is created with a GCond,
73 * and 3 refs (for the resolution thread, the calling thread, and
74 * the cancellation signal handler).
76 * a. If the resolution completes successfully, the thread pool
77 * function (threaded_resolver_thread()) will call
78 * g_threaded_resolver_request_complete(), which will detach
79 * the "cancelled" signal handler (dropping one ref on req)
80 * and signal the GCond, and then unref the req. The calling
81 * thread receives the signal from the GCond, processes the
82 * response, and unrefs the req, causing it to be freed.
84 * b. If the resolution is cancelled before completing,
85 * request_cancelled() will call
86 * g_threaded_resolver_request_complete(), which will detach
87 * the signal handler (as above, unreffing the req), set
88 * req->error to indicate that it was cancelled, and signal
89 * the GCond. The calling thread receives the signal from the
90 * GCond, processes the response, and unrefs the req.
91 * Eventually, the resolver thread finishes resolving (or
92 * times out in the resolver) and calls
93 * g_threaded_resolver_request_complete() again, but
94 * _request_complete() does nothing this time since the
95 * request is already complete. The thread pool func then
96 * unrefs the req, causing it to be freed.
98 * 3. Asynchronous request: A req is created with a GSimpleAsyncResult
99 * (and no GCond). The calling thread's ref on req is set up to be
100 * automatically dropped when the async_result is freed. Two
103 * a. If the resolution completes, the thread pool function
104 * (threaded_resolver_thread()) will call
105 * g_threaded_resolver_request_complete(), which will detach
106 * the "cancelled" signal handler (if it was present)
107 * (unreffing the req), queue the async_result to complete in
108 * an idle handler, unref the async_result (which is still
109 * reffed by the idle handler though), and then unref the req.
110 * The main thread then invokes the async_result's callback
111 * and processes the response. When it finishes, the
112 * async_result drops the ref that was taken by
113 * g_simple_async_result_complete_in_idle(), which causes the
114 * async_result to be freed, which causes req to be unreffed
117 * b. If the resolution is cancelled, request_cancelled() will
118 * call g_threaded_resolver_request_complete(), which will
119 * detach the signal handler (as above, unreffing the req) set
120 * req->error to indicate that it was cancelled, and queue and
121 * unref the async_result. The main thread completes the
122 * async_request and unrefs it and the req, as above.
123 * Eventually, the resolver thread finishes resolving (or
124 * times out in the resolver) and calls
125 * g_threaded_resolver_request_complete() again, but
126 * _request_complete() does nothing this time since the
127 * request is already complete. The thread pool func then
128 * unrefs the req, causing it to be freed.
130 * g_threaded_resolver_request_complete() ensures that if the request
131 * completes and cancels "at the same time" that only one of the two
132 * conditions gets processed.
135 typedef struct _GThreadedResolverRequest GThreadedResolverRequest
;
136 typedef void (*GThreadedResolverResolveFunc
) (GThreadedResolverRequest
*, GError
**);
137 typedef void (*GThreadedResolverFreeFunc
) (GThreadedResolverRequest
*);
139 struct _GThreadedResolverRequest
{
140 GThreadedResolverResolveFunc resolve_func
;
141 GThreadedResolverFreeFunc free_func
;
149 GInetAddress
*address
;
158 GCancellable
*cancellable
;
165 GSimpleAsyncResult
*async_result
;
170 static void g_threaded_resolver_request_unref (GThreadedResolverRequest
*req
);
171 static void request_cancelled (GCancellable
*cancellable
, gpointer req
);
172 static void request_cancelled_disconnect_notify (gpointer req
, GClosure
*closure
);
174 static GThreadedResolverRequest
*
175 g_threaded_resolver_request_new (GThreadedResolverResolveFunc resolve_func
,
176 GThreadedResolverFreeFunc free_func
,
177 GCancellable
*cancellable
)
179 GThreadedResolverRequest
*req
;
181 req
= g_slice_new0 (GThreadedResolverRequest
);
182 req
->resolve_func
= resolve_func
;
183 req
->free_func
= free_func
;
185 /* Initial refcount is 2; one for the caller and one for resolve_func */
188 g_mutex_init (&req
->mutex
);
189 g_cond_init (&req
->cond
);
190 /* Initially locked; caller must unlock */
191 g_mutex_lock (&req
->mutex
);
196 req
->cancellable
= g_object_ref (cancellable
);
197 g_signal_connect_data (cancellable
, "cancelled",
198 G_CALLBACK (request_cancelled
), req
,
199 request_cancelled_disconnect_notify
, 0);
206 g_threaded_resolver_request_unref (GThreadedResolverRequest
*req
)
210 g_mutex_lock (&req
->mutex
);
211 ref_count
= --req
->ref_count
;
212 g_mutex_unlock (&req
->mutex
);
216 g_mutex_clear (&req
->mutex
);
217 g_cond_clear (&req
->cond
);
220 g_error_free (req
->error
);
223 req
->free_func (req
);
225 /* We don't have to free req->cancellable or req->async_result,
226 * since (if set), they must already have been freed by
227 * request_complete() in order to get here.
230 g_slice_free (GThreadedResolverRequest
, req
);
234 g_threaded_resolver_request_complete (GThreadedResolverRequest
*req
,
237 g_mutex_lock (&req
->mutex
);
240 /* The req was cancelled, and now it has finished resolving as
241 * well. But we have nowhere to send the result, so just return.
243 g_mutex_unlock (&req
->mutex
);
244 g_clear_error (&error
);
248 req
->complete
= TRUE
;
249 g_mutex_unlock (&req
->mutex
);
252 g_propagate_error (&req
->error
, error
);
254 if (req
->cancellable
)
256 /* Drop the signal handler's ref on @req */
257 g_signal_handlers_disconnect_by_func (req
->cancellable
, request_cancelled
, req
);
258 g_object_unref (req
->cancellable
);
259 req
->cancellable
= NULL
;
262 if (req
->async_result
)
265 g_simple_async_result_set_from_error (req
->async_result
, req
->error
);
266 g_simple_async_result_complete_in_idle (req
->async_result
);
268 /* Drop our ref on the async_result, which will eventually cause
269 * it to drop its ref on req.
271 g_object_unref (req
->async_result
);
272 req
->async_result
= NULL
;
276 g_cond_signal (&req
->cond
);
280 request_cancelled (GCancellable
*cancellable
,
283 GThreadedResolverRequest
*req
= user_data
;
284 GError
*error
= NULL
;
286 g_cancellable_set_error_if_cancelled (req
->cancellable
, &error
);
287 g_threaded_resolver_request_complete (req
, error
);
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
;
307 GError
*error
= NULL
;
309 req
->resolve_func (req
, &error
);
310 g_threaded_resolver_request_complete (req
, error
);
311 g_threaded_resolver_request_unref (req
);
315 resolve_sync (GThreadedResolver
*gtr
,
316 GThreadedResolverRequest
*req
,
319 if (!req
->cancellable
)
321 req
->resolve_func (req
, error
);
322 g_mutex_unlock (&req
->mutex
);
324 g_threaded_resolver_request_complete (req
, FALSE
);
325 g_threaded_resolver_request_unref (req
);
329 g_thread_pool_push (gtr
->thread_pool
, req
, &req
->error
);
331 g_cond_wait (&req
->cond
, &req
->mutex
);
332 g_mutex_unlock (&req
->mutex
);
336 g_propagate_error (error
, req
->error
);
342 resolve_async (GThreadedResolver
*gtr
,
343 GThreadedResolverRequest
*req
,
344 GAsyncReadyCallback callback
,
348 req
->async_result
= g_simple_async_result_new (G_OBJECT (gtr
),
349 callback
, user_data
, tag
);
350 g_simple_async_result_set_op_res_gpointer (req
->async_result
, req
,
351 (GDestroyNotify
)g_threaded_resolver_request_unref
);
352 g_thread_pool_push (gtr
->thread_pool
, req
, NULL
);
353 g_mutex_unlock (&req
->mutex
);
356 static GThreadedResolverRequest
*
357 resolve_finish (GResolver
*resolver
,
358 GAsyncResult
*result
,
362 g_return_val_if_fail (g_simple_async_result_is_valid (result
, G_OBJECT (resolver
), tag
), NULL
);
364 return g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result
));
368 do_lookup_by_name (GThreadedResolverRequest
*req
,
371 struct addrinfo
*res
= NULL
;
374 retval
= getaddrinfo (req
->u
.name
.hostname
, NULL
,
375 &_g_resolver_addrinfo_hints
, &res
);
376 req
->u
.name
.addresses
=
377 _g_resolver_addresses_from_addrinfo (req
->u
.name
.hostname
, res
, retval
, error
);
383 lookup_by_name (GResolver
*resolver
,
384 const gchar
*hostname
,
385 GCancellable
*cancellable
,
388 GThreadedResolver
*gtr
= G_THREADED_RESOLVER (resolver
);
389 GThreadedResolverRequest
*req
;
392 req
= g_threaded_resolver_request_new (do_lookup_by_name
, NULL
, cancellable
);
393 req
->u
.name
.hostname
= (gchar
*)hostname
;
394 resolve_sync (gtr
, req
, error
);
396 addresses
= req
->u
.name
.addresses
;
397 g_threaded_resolver_request_unref (req
);
402 free_lookup_by_name (GThreadedResolverRequest
*req
)
404 g_free (req
->u
.name
.hostname
);
405 if (req
->u
.name
.addresses
)
406 g_resolver_free_addresses (req
->u
.name
.addresses
);
410 lookup_by_name_async (GResolver
*resolver
,
411 const gchar
*hostname
,
412 GCancellable
*cancellable
,
413 GAsyncReadyCallback callback
,
416 GThreadedResolver
*gtr
= G_THREADED_RESOLVER (resolver
);
417 GThreadedResolverRequest
*req
;
419 req
= g_threaded_resolver_request_new (do_lookup_by_name
, free_lookup_by_name
,
421 req
->u
.name
.hostname
= g_strdup (hostname
);
422 resolve_async (gtr
, req
, callback
, user_data
, lookup_by_name_async
);
426 lookup_by_name_finish (GResolver
*resolver
,
427 GAsyncResult
*result
,
430 GThreadedResolverRequest
*req
;
433 req
= resolve_finish (resolver
, result
, lookup_by_name_async
, error
);
434 addresses
= req
->u
.name
.addresses
;
435 req
->u
.name
.addresses
= NULL
;
441 do_lookup_by_address (GThreadedResolverRequest
*req
,
444 struct sockaddr_storage sockaddr
;
446 gchar name
[NI_MAXHOST
];
449 _g_resolver_address_to_sockaddr (req
->u
.address
.address
,
450 &sockaddr
, &sockaddr_size
);
452 retval
= getnameinfo ((struct sockaddr
*)&sockaddr
, sockaddr_size
,
453 name
, sizeof (name
), NULL
, 0, NI_NAMEREQD
);
454 req
->u
.address
.name
= _g_resolver_name_from_nameinfo (req
->u
.address
.address
,
455 name
, retval
, error
);
459 lookup_by_address (GResolver
*resolver
,
460 GInetAddress
*address
,
461 GCancellable
*cancellable
,
464 GThreadedResolver
*gtr
= G_THREADED_RESOLVER (resolver
);
465 GThreadedResolverRequest
*req
;
468 req
= g_threaded_resolver_request_new (do_lookup_by_address
, NULL
, cancellable
);
469 req
->u
.address
.address
= address
;
470 resolve_sync (gtr
, req
, error
);
472 name
= req
->u
.address
.name
;
473 g_threaded_resolver_request_unref (req
);
478 free_lookup_by_address (GThreadedResolverRequest
*req
)
480 g_object_unref (req
->u
.address
.address
);
481 if (req
->u
.address
.name
)
482 g_free (req
->u
.address
.name
);
486 lookup_by_address_async (GResolver
*resolver
,
487 GInetAddress
*address
,
488 GCancellable
*cancellable
,
489 GAsyncReadyCallback callback
,
492 GThreadedResolver
*gtr
= G_THREADED_RESOLVER (resolver
);
493 GThreadedResolverRequest
*req
;
495 req
= g_threaded_resolver_request_new (do_lookup_by_address
,
496 free_lookup_by_address
,
498 req
->u
.address
.address
= g_object_ref (address
);
499 resolve_async (gtr
, req
, callback
, user_data
, lookup_by_address_async
);
503 lookup_by_address_finish (GResolver
*resolver
,
504 GAsyncResult
*result
,
507 GThreadedResolverRequest
*req
;
510 req
= resolve_finish (resolver
, result
, lookup_by_address_async
, error
);
511 name
= req
->u
.address
.name
;
512 req
->u
.address
.name
= NULL
;
518 do_lookup_service (GThreadedResolverRequest
*req
,
521 #if defined(G_OS_UNIX)
524 #elif defined(G_OS_WIN32)
529 #if defined(G_OS_UNIX)
530 len
= res_query (req
->u
.service
.rrname
, C_IN
, T_SRV
, answer
, sizeof (answer
));
532 req
->u
.service
.targets
= _g_resolver_targets_from_res_query (req
->u
.service
.rrname
, answer
, len
, herr
, error
);
533 #elif defined(G_OS_WIN32)
534 status
= DnsQuery_A (req
->u
.service
.rrname
, DNS_TYPE_SRV
,
535 DNS_QUERY_STANDARD
, NULL
, &results
, NULL
);
536 req
->u
.service
.targets
= _g_resolver_targets_from_DnsQuery (req
->u
.service
.rrname
, status
, results
, error
);
537 DnsRecordListFree (results
, DnsFreeRecordList
);
542 lookup_service (GResolver
*resolver
,
544 GCancellable
*cancellable
,
547 GThreadedResolver
*gtr
= G_THREADED_RESOLVER (resolver
);
548 GThreadedResolverRequest
*req
;
551 req
= g_threaded_resolver_request_new (do_lookup_service
, NULL
, cancellable
);
552 req
->u
.service
.rrname
= (char *)rrname
;
553 resolve_sync (gtr
, req
, error
);
555 targets
= req
->u
.service
.targets
;
556 g_threaded_resolver_request_unref (req
);
561 free_lookup_service (GThreadedResolverRequest
*req
)
563 g_free (req
->u
.service
.rrname
);
564 if (req
->u
.service
.targets
)
565 g_resolver_free_targets (req
->u
.service
.targets
);
569 lookup_service_async (GResolver
*resolver
,
571 GCancellable
*cancellable
,
572 GAsyncReadyCallback callback
,
575 GThreadedResolver
*gtr
= G_THREADED_RESOLVER (resolver
);
576 GThreadedResolverRequest
*req
;
578 req
= g_threaded_resolver_request_new (do_lookup_service
,
581 req
->u
.service
.rrname
= g_strdup (rrname
);
582 resolve_async (gtr
, req
, callback
, user_data
, lookup_service_async
);
586 lookup_service_finish (GResolver
*resolver
,
587 GAsyncResult
*result
,
590 GThreadedResolverRequest
*req
;
593 req
= resolve_finish (resolver
, result
, lookup_service_async
, error
);
594 targets
= req
->u
.service
.targets
;
595 req
->u
.service
.targets
= NULL
;
601 g_threaded_resolver_class_init (GThreadedResolverClass
*threaded_class
)
603 GResolverClass
*resolver_class
= G_RESOLVER_CLASS (threaded_class
);
604 GObjectClass
*object_class
= G_OBJECT_CLASS (threaded_class
);
606 resolver_class
->lookup_by_name
= lookup_by_name
;
607 resolver_class
->lookup_by_name_async
= lookup_by_name_async
;
608 resolver_class
->lookup_by_name_finish
= lookup_by_name_finish
;
609 resolver_class
->lookup_by_address
= lookup_by_address
;
610 resolver_class
->lookup_by_address_async
= lookup_by_address_async
;
611 resolver_class
->lookup_by_address_finish
= lookup_by_address_finish
;
612 resolver_class
->lookup_service
= lookup_service
;
613 resolver_class
->lookup_service_async
= lookup_service_async
;
614 resolver_class
->lookup_service_finish
= lookup_service_finish
;
616 object_class
->finalize
= finalize
;