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
;