gio/gthreadedresolver.c

   1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
   2
   3 /* GIO - GLib Input, Output and Streaming Library
   4  *
   5  * Copyright (C) 2008 Red Hat, Inc.
   6  *
   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.
  11  *
  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.
  16  *
  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.
  21  */
  22
  23 #include "config.h"
  24 #include <glib.h>
  25 #include "glibintl.h"
  26
  27 #include <stdio.h>
  28 #include <string.h>
  29
  30 #include "gthreadedresolver.h"
  31 #include "gnetworkingprivate.h"
  32
  33 #include "gcancellable.h"
  34 #include "gsimpleasyncresult.h"
  35 #include "gsocketaddress.h"
  36
  37 #include "gioalias.h"
  38
  39 G_DEFINE_TYPE (GThreadedResolver, g_threaded_resolver, G_TYPE_RESOLVER)
  40
  41 static void threaded_resolver_thread (gpointer thread_data, gpointer pool_data);
  42
  43 static void
  44 g_threaded_resolver_init (GThreadedResolver *gtr)
  45 {
  46   if (g_thread_supported ())
  47     gtr->thread_pool = g_thread_pool_new (threaded_resolver_thread, gtr,
  48                                           -1, FALSE, NULL);
  49 }
  50
  51 static void
  52 finalize (GObject *object)
  53 {
  54   GThreadedResolver *gtr = G_THREADED_RESOLVER (object);
  55
  56   g_thread_pool_free (gtr->thread_pool, FALSE, FALSE);
  57
  58   G_OBJECT_CLASS (g_threaded_resolver_parent_class)->finalize (object);
  59 }
  60
  61 /* A GThreadedResolverRequest represents a request in progress
  62  * (usually, but see case 1). It is refcounted, to make sure that it
  63  * doesn't get freed too soon. In particular, it can't be freed until
  64  * (a) the resolver thread has finished resolving, (b) the calling
  65  * thread has received an answer, and (c) no other thread could be in
  66  * the process of trying to cancel it.
  67  *
  68  * The possibilities:
  69  *
  70  * 1. Synchronous non-cancellable request: in this case, the request
  71  *    is simply done in the calling thread, without using
  72  *    GThreadedResolverRequest at all.
  73  *
  74  * 2. Synchronous cancellable request: A req is created with a GCond,
  75  *    and 3 refs (for the resolution thread, the calling thread, and
  76  *    the cancellation signal handler).
  77  *
  78  *      a. If the resolution completes successfully, the thread pool
  79  *         function (threaded_resolver_thread()) will call
  80  *         g_threaded_resolver_request_complete(), which will detach
  81  *         the "cancelled" signal handler (dropping one ref on req)
  82  *         and signal the GCond, and then unref the req. The calling
  83  *         thread receives the signal from the GCond, processes the
  84  *         response, and unrefs the req, causing it to be freed.
  85  *
  86  *      b. If the resolution is cancelled before completing,
  87  *         request_cancelled() will call
  88  *         g_threaded_resolver_request_complete(), which will detach
  89  *         the signal handler (as above, unreffing the req), set
  90  *         req->error to indicate that it was cancelled, and signal
  91  *         the GCond. The calling thread receives the signal from the
  92  *         GCond, processes the response, and unrefs the req.
  93  *         Eventually, the resolver thread finishes resolving (or
  94  *         times out in the resolver) and calls
  95  *         g_threaded_resolver_request_complete() again, but
  96  *         _request_complete() does nothing this time since the
  97  *         request is already complete. The thread pool func then
  98  *         unrefs the req, causing it to be freed.
  99  *
 100  * 3. Asynchronous request: A req is created with a GSimpleAsyncResult
 101  *    (and no GCond). The calling thread's ref on req is set up to be
 102  *    automatically dropped when the async_result is freed. Two
 103  *    sub-possibilities:
 104  *
 105  *      a. If the resolution completes, the thread pool function
 106  *         (threaded_resolver_thread()) will call
 107  *         g_threaded_resolver_request_complete(), which will detach
 108  *         the "cancelled" signal handler (if it was present)
 109  *         (unreffing the req), queue the async_result to complete in
 110  *         an idle handler, unref the async_result (which is still
 111  *         reffed by the idle handler though), and then unref the req.
 112  *         The main thread then invokes the async_result's callback
 113  *         and processes the response. When it finishes, the
 114  *         async_result drops the ref that was taken by
 115  *         g_simple_async_result_complete_in_idle(), which causes the
 116  *         async_result to be freed, which causes req to be unreffed
 117  *         and freed.
 118  *
 119  *      b. If the resolution is cancelled, request_cancelled() will
 120  *         call g_threaded_resolver_request_complete(), which will
 121  *         detach the signal handler (as above, unreffing the req) set
 122  *         req->error to indicate that it was cancelled, and queue and
 123  *         unref the async_result. The main thread completes the
 124  *         async_request and unrefs it and the req, as above.
 125  *         Eventually, the resolver thread finishes resolving (or
 126  *         times out in the resolver) and calls
 127  *         g_threaded_resolver_request_complete() again, but
 128  *         _request_complete() does nothing this time since the
 129  *         request is already complete. The thread pool func then
 130  *         unrefs the req, causing it to be freed.
 131  *
 132  * g_threaded_resolver_request_complete() ensures that if the request
 133  * completes and cancels "at the same time" that only one of the two
 134  * conditions gets processed.
 135  */
 136
 137 typedef struct _GThreadedResolverRequest GThreadedResolverRequest;
 138 typedef void (*GThreadedResolverResolveFunc) (GThreadedResolverRequest *, GError **);
 139 typedef void (*GThreadedResolverFreeFunc) (GThreadedResolverRequest *);
 140
 141 struct _GThreadedResolverRequest {
 142   GThreadedResolverResolveFunc resolve_func;
 143   GThreadedResolverFreeFunc free_func;
 144
 145   union {
 146     struct {
 147       gchar *hostname;
 148       GList *addresses;
 149     } name;
 150     struct {
 151       GInetAddress *address;
 152       gchar *name;
 153     } address;
 154     struct {
 155       gchar *rrname;
 156       GList *targets;
 157     } service;
 158   } u;
 159
 160   GCancellable *cancellable;
 161   GError *error;
 162
 163   GMutex *mutex;
 164   guint ref_count;
 165
 166   GCond *cond;
 167   GSimpleAsyncResult *async_result;
 168   gboolean complete;
 169
 170 };
 171
 172 static void g_threaded_resolver_request_unref (GThreadedResolverRequest *req);
 173 static void request_cancelled (GCancellable *cancellable, gpointer req);
 174 static void request_cancelled_disconnect_notify (gpointer req, GClosure *closure);
 175
 176 static GThreadedResolverRequest *
 177 g_threaded_resolver_request_new (GThreadedResolverResolveFunc  resolve_func,
 178                                  GThreadedResolverFreeFunc     free_func,
 179                                  GCancellable                 *cancellable)
 180 {
 181   GThreadedResolverRequest *req;
 182
 183   req = g_slice_new0 (GThreadedResolverRequest);
 184   req->resolve_func = resolve_func;
 185   req->free_func = free_func;
 186
 187   /* Initial refcount is 2; one for the caller and one for resolve_func */
 188   req->ref_count = 2;
 189
 190   if (g_thread_supported ())
 191     req->mutex = g_mutex_new ();
 192   /* Initially locked; caller must unlock */
 193   g_mutex_lock (req->mutex);
 194
 195   if (cancellable)
 196     {
 197       req->ref_count++;
 198       req->cancellable = g_object_ref (cancellable);
 199       g_signal_connect_data (cancellable, "cancelled",
 200                              G_CALLBACK (request_cancelled), req,
 201                              request_cancelled_disconnect_notify, 0);
 202     }
 203
 204   return req;
 205 }
 206
 207 static void
 208 g_threaded_resolver_request_unref (GThreadedResolverRequest *req)
 209 {
 210   guint ref_count;
 211
 212   g_mutex_lock (req->mutex);
 213   ref_count = --req->ref_count;
 214   g_mutex_unlock (req->mutex);
 215   if (ref_count > 0)
 216     return;
 217
 218   g_mutex_free (req->mutex);
 219
 220   if (req->cond)
 221     g_cond_free (req->cond);
 222
 223   if (req->error)
 224     g_error_free (req->error);
 225
 226   if (req->free_func)
 227     req->free_func (req);
 228
 229   /* We don't have to free req->cancellable or req->async_result,
 230    * since (if set), they must already have been freed by
 231    * request_complete() in order to get here.
 232    */
 233
 234   g_slice_free (GThreadedResolverRequest, req);
 235 }
 236
 237 static void
 238 g_threaded_resolver_request_complete (GThreadedResolverRequest *req,
 239                                       gboolean                  cancelled)
 240 {
 241   g_mutex_lock (req->mutex);
 242   if (req->complete)
 243     {
 244       /* The req was cancelled, and now it has finished resolving as
 245        * well. But we have nowhere to send the result, so just return.
 246        */
 247       g_mutex_unlock (req->mutex);
 248       return;
 249     }
 250
 251   req->complete = TRUE;
 252   g_mutex_unlock (req->mutex);
 253
 254   if (req->cancellable)
 255     {
 256       /* Possibly propagate a cancellation error */
 257       if (cancelled && !req->error)
 258         g_cancellable_set_error_if_cancelled (req->cancellable, &req->error);
 259
 260       /* Drop the signal handler's ref on @req */
 261       g_signal_handlers_disconnect_by_func (req->cancellable, request_cancelled, req);
 262       g_object_unref (req->cancellable);
 263       req->cancellable = NULL;
 264     }
 265
 266   if (req->cond)
 267     g_cond_signal (req->cond);
 268   else if (req->async_result)
 269     {
 270       if (req->error)
 271         g_simple_async_result_set_from_error (req->async_result, req->error);
 272       g_simple_async_result_complete_in_idle (req->async_result);
 273
 274       /* Drop our ref on the async_result, which will eventually cause
 275        * it to drop its ref on req.
 276        */
 277       g_object_unref (req->async_result);
 278       req->async_result = NULL;
 279     }
 280 }
 281
 282 static void
 283 request_cancelled (GCancellable *cancellable,
 284                    gpointer      user_data)
 285 {
 286   GThreadedResolverRequest *req = user_data;
 287
 288   g_threaded_resolver_request_complete (req, TRUE);
 289
 290   /* We can't actually cancel the resolver thread; it will eventually
 291    * complete on its own and call request_complete() again, which will
 292    * do nothing the second time.
 293    */
 294 }
 295
 296 static void
 297 request_cancelled_disconnect_notify (gpointer  req,
 298                                      GClosure *closure)
 299 {
 300   g_threaded_resolver_request_unref (req);
 301 }
 302
 303 static void
 304 threaded_resolver_thread (gpointer thread_data,
 305                           gpointer pool_data)
 306 {
 307   GThreadedResolverRequest *req = thread_data;
 308
 309   req->resolve_func (req, &req->error);
 310   g_threaded_resolver_request_complete (req, FALSE);
 311   g_threaded_resolver_request_unref (req);
 312 }
 313
 314 static void
 315 resolve_sync (GThreadedResolver         *gtr,
 316               GThreadedResolverRequest  *req,
 317               GError                   **error)
 318 {
 319   if (!req->cancellable || !gtr->thread_pool)
 320     {
 321       req->resolve_func (req, error);
 322       g_mutex_unlock (req->mutex);
 323       return;
 324     }
 325
 326   req->cond = g_cond_new ();
 327   g_thread_pool_push (gtr->thread_pool, req, NULL);
 328   g_cond_wait (req->cond, req->mutex);
 329   g_mutex_unlock (req->mutex);
 330
 331   if (req->error)
 332     {
 333       g_propagate_error (error, req->error);
 334       req->error = NULL;
 335     }
 336 }
 337
 338 static void
 339 resolve_async (GThreadedResolver        *gtr,
 340                GThreadedResolverRequest *req,
 341                GAsyncReadyCallback       callback,
 342                gpointer                  user_data,
 343                gpointer                  tag)
 344 {
 345   req->async_result = g_simple_async_result_new (G_OBJECT (gtr),
 346                                                  callback, user_data, tag);
 347   g_simple_async_result_set_op_res_gpointer (req->async_result, req, NULL);
 348   g_thread_pool_push (gtr->thread_pool, req, NULL);
 349   g_mutex_unlock (req->mutex);
 350 }
 351
 352 static GThreadedResolverRequest *
 353 resolve_finish (GResolver     *resolver,
 354                 GAsyncResult  *result,
 355                 gpointer       tag,
 356                 GError       **error)
 357 {
 358   g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (resolver), tag), NULL);
 359
 360   return g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
 361 }
 362
 363 static void
 364 do_lookup_by_name (GThreadedResolverRequest  *req,
 365                    GError                   **error)
 366 {
 367   struct addrinfo *res = NULL;
 368   gint retval;
 369
 370   retval = getaddrinfo (req->u.name.hostname, NULL,
 371                         &_g_resolver_addrinfo_hints, &res);
 372   req->u.name.addresses =
 373     _g_resolver_addresses_from_addrinfo (req->u.name.hostname, res, retval, error);
 374   if (res)
 375     freeaddrinfo (res);
 376 }
 377
 378 static GList *
 379 lookup_by_name (GResolver     *resolver,
 380                 const gchar   *hostname,
 381                 GCancellable  *cancellable,
 382                 GError       **error)
 383 {
 384   GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
 385   GThreadedResolverRequest *req;
 386   GList *addresses;
 387
 388   req = g_threaded_resolver_request_new (do_lookup_by_name, NULL, cancellable);
 389   req->u.name.hostname = (gchar *)hostname;
 390   resolve_sync (gtr, req, error);
 391
 392   addresses = req->u.name.addresses;
 393   g_threaded_resolver_request_unref (req);
 394   return addresses;
 395 }
 396
 397 static void
 398 free_lookup_by_name (GThreadedResolverRequest *req)
 399 {
 400   g_free (req->u.name.hostname);
 401   if (req->u.name.addresses)
 402     g_resolver_free_addresses (req->u.name.addresses);
 403 }
 404
 405 static void
 406 lookup_by_name_async (GResolver           *resolver,
 407                       const gchar         *hostname,
 408                       GCancellable        *cancellable,
 409                       GAsyncReadyCallback  callback,
 410                       gpointer             user_data)
 411 {
 412   GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
 413   GThreadedResolverRequest *req;
 414
 415   req = g_threaded_resolver_request_new (do_lookup_by_name, free_lookup_by_name,
 416                                          cancellable);
 417   req->u.name.hostname = g_strdup (hostname);
 418   resolve_async (gtr, req, callback, user_data, lookup_by_name_async);
 419 }
 420
 421 static GList *
 422 lookup_by_name_finish (GResolver     *resolver,
 423                        GAsyncResult  *result,
 424                        GError       **error)
 425 {
 426   GThreadedResolverRequest *req;
 427   GList *addresses;
 428
 429   req = resolve_finish (resolver, result, lookup_by_name_async, error);
 430   addresses = req->u.name.addresses;
 431   req->u.name.addresses = NULL;
 432   return addresses;
 433 }
 434
 435
 436 static void
 437 do_lookup_by_address (GThreadedResolverRequest  *req,
 438                       GError                   **error)
 439 {
 440   struct sockaddr_storage sockaddr;
 441   gsize sockaddr_size;
 442   gchar name[NI_MAXHOST];
 443   gint retval;
 444
 445   _g_resolver_address_to_sockaddr (req->u.address.address,
 446                                    &sockaddr, &sockaddr_size);
 447
 448   retval = getnameinfo ((struct sockaddr *)&sockaddr, sockaddr_size,
 449                         name, sizeof (name), NULL, 0, NI_NAMEREQD);
 450   req->u.address.name = _g_resolver_name_from_nameinfo (req->u.address.address,
 451                                                         name, retval, error);
 452 }
 453
 454 static gchar *
 455 lookup_by_address (GResolver        *resolver,
 456                    GInetAddress     *address,
 457                    GCancellable     *cancellable,
 458                    GError          **error)
 459 {
 460   GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
 461   GThreadedResolverRequest *req;
 462   gchar *name;
 463
 464   req = g_threaded_resolver_request_new (do_lookup_by_address, NULL, cancellable);
 465   req->u.address.address = address;
 466   resolve_sync (gtr, req, error);
 467
 468   name = req->u.address.name;
 469   g_threaded_resolver_request_unref (req);
 470   return name;
 471 }
 472
 473 static void
 474 free_lookup_by_address (GThreadedResolverRequest *req)
 475 {
 476   g_object_unref (req->u.address.address);
 477   if (req->u.address.name)
 478     g_free (req->u.address.name);
 479 }
 480
 481 static void
 482 lookup_by_address_async (GResolver           *resolver,
 483                          GInetAddress        *address,
 484                          GCancellable        *cancellable,
 485                          GAsyncReadyCallback  callback,
 486                          gpointer             user_data)
 487 {
 488   GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
 489   GThreadedResolverRequest *req;
 490
 491   req = g_threaded_resolver_request_new (do_lookup_by_address,
 492                                          free_lookup_by_address,
 493                                          cancellable);
 494   req->u.address.address = g_object_ref (address);
 495   resolve_async (gtr, req, callback, user_data, lookup_by_address_async);
 496 }
 497
 498 static gchar *
 499 lookup_by_address_finish (GResolver     *resolver,
 500                           GAsyncResult  *result,
 501                           GError       **error)
 502 {
 503   GThreadedResolverRequest *req;
 504   gchar *name;
 505
 506   req = resolve_finish (resolver, result, lookup_by_address_async, error);
 507   name = req->u.address.name;
 508   req->u.address.name = NULL;
 509   return name;
 510 }
 511
 512
 513 static void
 514 do_lookup_service (GThreadedResolverRequest *req,
 515                    GError   **error)
 516 {
 517 #if defined(G_OS_UNIX)
 518   gint len, herr;
 519   guchar answer[1024];
 520 #elif defined(G_OS_WIN32)
 521   DNS_STATUS status;
 522   DNS_RECORD *results;
 523 #endif
 524
 525 #if defined(G_OS_UNIX)
 526   len = res_query (req->u.service.rrname, C_IN, T_SRV, answer, sizeof (answer));
 527   herr = h_errno;
 528   req->u.service.targets = _g_resolver_targets_from_res_query (req->u.service.rrname, answer, len, herr, error);
 529 #elif defined(G_OS_WIN32)
 530   status = DnsQuery_A (req->u.service.rrname, DNS_TYPE_SRV,
 531                        DNS_QUERY_STANDARD, NULL, &results, NULL);
 532   req->u.service.targets = _g_resolver_targets_from_DnsQuery (req->u.service.rrname, status, results, error);
 533   DnsRecordListFree (results, DnsFreeRecordList);
 534 #endif
 535 }
 536
 537 static GList *
 538 lookup_service (GResolver        *resolver,
 539                 const gchar      *rrname,
 540                 GCancellable     *cancellable,
 541                 GError          **error)
 542 {
 543   GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
 544   GThreadedResolverRequest *req;
 545   GList *targets;
 546
 547   req = g_threaded_resolver_request_new (do_lookup_service, NULL, cancellable);
 548   req->u.service.rrname = (char *)rrname;
 549   resolve_sync (gtr, req, error);
 550
 551   targets = req->u.service.targets;
 552   g_threaded_resolver_request_unref (req);
 553   return targets;
 554 }
 555
 556 static void
 557 free_lookup_service (GThreadedResolverRequest *req)
 558 {
 559   g_free (req->u.service.rrname);
 560   if (req->u.service.targets)
 561     g_resolver_free_targets (req->u.service.targets);
 562 }
 563
 564 static void
 565 lookup_service_async (GResolver           *resolver,
 566                       const char          *rrname,
 567                       GCancellable        *cancellable,
 568                       GAsyncReadyCallback  callback,
 569                       gpointer             user_data)
 570 {
 571   GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
 572   GThreadedResolverRequest *req;
 573
 574   req = g_threaded_resolver_request_new (do_lookup_service,
 575                                          free_lookup_service,
 576                                          cancellable);
 577   req->u.service.rrname = g_strdup (rrname);
 578   resolve_async (gtr, req, callback, user_data, lookup_service_async);
 579 }
 580
 581 static GList *
 582 lookup_service_finish (GResolver     *resolver,
 583                        GAsyncResult  *result,
 584                        GError       **error)
 585 {
 586   GThreadedResolverRequest *req;
 587   GList *targets;
 588
 589   req = resolve_finish (resolver, result, lookup_service_async, error);
 590   targets = req->u.service.targets;
 591   req->u.service.targets = NULL;
 592   return targets;
 593 }
 594
 595
 596 static void
 597 g_threaded_resolver_class_init (GThreadedResolverClass *threaded_class)
 598 {
 599   GResolverClass *resolver_class = G_RESOLVER_CLASS (threaded_class);
 600   GObjectClass *object_class = G_OBJECT_CLASS (threaded_class);
 601
 602   resolver_class->lookup_by_name           = lookup_by_name;
 603   resolver_class->lookup_by_name_async     = lookup_by_name_async;
 604   resolver_class->lookup_by_name_finish    = lookup_by_name_finish;
 605   resolver_class->lookup_by_address        = lookup_by_address;
 606   resolver_class->lookup_by_address_async  = lookup_by_address_async;
 607   resolver_class->lookup_by_address_finish = lookup_by_address_finish;
 608   resolver_class->lookup_service           = lookup_service;
 609   resolver_class->lookup_service_async     = lookup_service_async;
 610   resolver_class->lookup_service_finish    = lookup_service_finish;
 611
 612   object_class->finalize = finalize;
 613 }
 614
 615 #define __G_THREADED_RESOLVER_C__
 616 #include "gioaliasdef.c"