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
  38 G_DEFINE_TYPE (GThreadedResolver, g_threaded_resolver, G_TYPE_RESOLVER)
  39
  40 static void threaded_resolver_thread (gpointer thread_data, gpointer pool_data);
  41
  42 static void
  43 g_threaded_resolver_init (GThreadedResolver *gtr)
  44 {
  45   if (g_thread_supported ())
  46     gtr->thread_pool = g_thread_pool_new (threaded_resolver_thread, gtr,
  47                                           -1, FALSE, NULL);
  48 }
  49
  50 static void
  51 finalize (GObject *object)
  52 {
  53   GThreadedResolver *gtr = G_THREADED_RESOLVER (object);
  54
  55   g_thread_pool_free (gtr->thread_pool, FALSE, FALSE);
  56
  57   G_OBJECT_CLASS (g_threaded_resolver_parent_class)->finalize (object);
  58 }
  59
  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.
  66  *
  67  * The possibilities:
  68  *
  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.
  72  *
  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).
  76  *
  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.
  84  *
  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.
  98  *
  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
 102  *    sub-possibilities:
 103  *
 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
 116  *         and freed.
 117  *
 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.
 130  *
 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.
 134  */
 135
 136 typedef struct _GThreadedResolverRequest GThreadedResolverRequest;
 137 typedef void (*GThreadedResolverResolveFunc) (GThreadedResolverRequest *, GError **);
 138 typedef void (*GThreadedResolverFreeFunc) (GThreadedResolverRequest *);
 139
 140 struct _GThreadedResolverRequest {
 141   GThreadedResolverResolveFunc resolve_func;
 142   GThreadedResolverFreeFunc free_func;
 143
 144   union {
 145     struct {
 146       gchar *hostname;
 147       GList *addresses;
 148     } name;
 149     struct {
 150       GInetAddress *address;
 151       gchar *name;
 152     } address;
 153     struct {
 154       gchar *rrname;
 155       GList *targets;
 156     } service;
 157   } u;
 158
 159   GCancellable *cancellable;
 160   GError *error;
 161
 162   GMutex *mutex;
 163   guint ref_count;
 164
 165   GCond *cond;
 166   GSimpleAsyncResult *async_result;
 167   gboolean complete;
 168
 169 };
 170
 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);
 174
 175 static GThreadedResolverRequest *
 176 g_threaded_resolver_request_new (GThreadedResolverResolveFunc  resolve_func,
 177                                  GThreadedResolverFreeFunc     free_func,
 178                                  GCancellable                 *cancellable)
 179 {
 180   GThreadedResolverRequest *req;
 181
 182   req = g_slice_new0 (GThreadedResolverRequest);
 183   req->resolve_func = resolve_func;
 184   req->free_func = free_func;
 185
 186   /* Initial refcount is 2; one for the caller and one for resolve_func */
 187   req->ref_count = 2;
 188
 189   if (g_thread_supported ())
 190     req->mutex = g_mutex_new ();
 191   /* Initially locked; caller must unlock */
 192   g_mutex_lock (req->mutex);
 193
 194   if (cancellable)
 195     {
 196       req->ref_count++;
 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);
 201     }
 202
 203   return req;
 204 }
 205
 206 static void
 207 g_threaded_resolver_request_unref (GThreadedResolverRequest *req)
 208 {
 209   guint ref_count;
 210
 211   g_mutex_lock (req->mutex);
 212   ref_count = --req->ref_count;
 213   g_mutex_unlock (req->mutex);
 214   if (ref_count > 0)
 215     return;
 216
 217   g_mutex_free (req->mutex);
 218
 219   if (req->cond)
 220     g_cond_free (req->cond);
 221
 222   if (req->error)
 223     g_error_free (req->error);
 224
 225   if (req->free_func)
 226     req->free_func (req);
 227
 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.
 231    */
 232
 233   g_slice_free (GThreadedResolverRequest, req);
 234 }
 235
 236 static void
 237 g_threaded_resolver_request_complete (GThreadedResolverRequest *req,
 238                                       gboolean                  cancelled)
 239 {
 240   g_mutex_lock (req->mutex);
 241   if (req->complete)
 242     {
 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.
 245        */
 246       g_mutex_unlock (req->mutex);
 247       return;
 248     }
 249
 250   req->complete = TRUE;
 251   g_mutex_unlock (req->mutex);
 252
 253   if (req->cancellable)
 254     {
 255       /* Possibly propagate a cancellation error */
 256       if (cancelled && !req->error)
 257         g_cancellable_set_error_if_cancelled (req->cancellable, &req->error);
 258
 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;
 263     }
 264
 265   if (req->cond)
 266     g_cond_signal (req->cond);
 267   else if (req->async_result)
 268     {
 269       if (req->error)
 270         g_simple_async_result_set_from_error (req->async_result, req->error);
 271       g_simple_async_result_complete_in_idle (req->async_result);
 272
 273       /* Drop our ref on the async_result, which will eventually cause
 274        * it to drop its ref on req.
 275        */
 276       g_object_unref (req->async_result);
 277       req->async_result = NULL;
 278     }
 279 }
 280
 281 static void
 282 request_cancelled (GCancellable *cancellable,
 283                    gpointer      user_data)
 284 {
 285   GThreadedResolverRequest *req = user_data;
 286
 287   g_threaded_resolver_request_complete (req, TRUE);
 288
 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.
 292    */
 293 }
 294
 295 static void
 296 request_cancelled_disconnect_notify (gpointer  req,
 297                                      GClosure *closure)
 298 {
 299   g_threaded_resolver_request_unref (req);
 300 }
 301
 302 static void
 303 threaded_resolver_thread (gpointer thread_data,
 304                           gpointer pool_data)
 305 {
 306   GThreadedResolverRequest *req = thread_data;
 307
 308   req->resolve_func (req, &req->error);
 309   g_threaded_resolver_request_complete (req, FALSE);
 310   g_threaded_resolver_request_unref (req);
 311 }
 312
 313 static void
 314 resolve_sync (GThreadedResolver         *gtr,
 315               GThreadedResolverRequest  *req,
 316               GError                   **error)
 317 {
 318   if (!req->cancellable || !gtr->thread_pool)
 319     {
 320       req->resolve_func (req, error);
 321       g_mutex_unlock (req->mutex);
 322
 323       g_threaded_resolver_request_complete (req, FALSE);
 324       g_threaded_resolver_request_unref (req);
 325       return;
 326     }
 327
 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);
 332
 333   if (req->error)
 334     {
 335       g_propagate_error (error, req->error);
 336       req->error = NULL;
 337     }
 338 }
 339
 340 static void
 341 resolve_async (GThreadedResolver        *gtr,
 342                GThreadedResolverRequest *req,
 343                GAsyncReadyCallback       callback,
 344                gpointer                  user_data,
 345                gpointer                  tag)
 346 {
 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);
 353 }
 354
 355 static GThreadedResolverRequest *
 356 resolve_finish (GResolver     *resolver,
 357                 GAsyncResult  *result,
 358                 gpointer       tag,
 359                 GError       **error)
 360 {
 361   g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (resolver), tag), NULL);
 362
 363   return g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
 364 }
 365
 366 static void
 367 do_lookup_by_name (GThreadedResolverRequest  *req,
 368                    GError                   **error)
 369 {
 370   struct addrinfo *res = NULL;
 371   gint retval;
 372
 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);
 377   if (res)
 378     freeaddrinfo (res);
 379 }
 380
 381 static GList *
 382 lookup_by_name (GResolver     *resolver,
 383                 const gchar   *hostname,
 384                 GCancellable  *cancellable,
 385                 GError       **error)
 386 {
 387   GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
 388   GThreadedResolverRequest *req;
 389   GList *addresses;
 390
 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);
 394
 395   addresses = req->u.name.addresses;
 396   g_threaded_resolver_request_unref (req);
 397   return addresses;
 398 }
 399
 400 static void
 401 free_lookup_by_name (GThreadedResolverRequest *req)
 402 {
 403   g_free (req->u.name.hostname);
 404   if (req->u.name.addresses)
 405     g_resolver_free_addresses (req->u.name.addresses);
 406 }
 407
 408 static void
 409 lookup_by_name_async (GResolver           *resolver,
 410                       const gchar         *hostname,
 411                       GCancellable        *cancellable,
 412                       GAsyncReadyCallback  callback,
 413                       gpointer             user_data)
 414 {
 415   GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
 416   GThreadedResolverRequest *req;
 417
 418   req = g_threaded_resolver_request_new (do_lookup_by_name, free_lookup_by_name,
 419                                          cancellable);
 420   req->u.name.hostname = g_strdup (hostname);
 421   resolve_async (gtr, req, callback, user_data, lookup_by_name_async);
 422 }
 423
 424 static GList *
 425 lookup_by_name_finish (GResolver     *resolver,
 426                        GAsyncResult  *result,
 427                        GError       **error)
 428 {
 429   GThreadedResolverRequest *req;
 430   GList *addresses;
 431
 432   req = resolve_finish (resolver, result, lookup_by_name_async, error);
 433   addresses = req->u.name.addresses;
 434   req->u.name.addresses = NULL;
 435   return addresses;
 436 }
 437
 438
 439 static void
 440 do_lookup_by_address (GThreadedResolverRequest  *req,
 441                       GError                   **error)
 442 {
 443   struct sockaddr_storage sockaddr;
 444   gsize sockaddr_size;
 445   gchar name[NI_MAXHOST];
 446   gint retval;
 447
 448   _g_resolver_address_to_sockaddr (req->u.address.address,
 449                                    &sockaddr, &sockaddr_size);
 450
 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);
 455 }
 456
 457 static gchar *
 458 lookup_by_address (GResolver        *resolver,
 459                    GInetAddress     *address,
 460                    GCancellable     *cancellable,
 461                    GError          **error)
 462 {
 463   GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
 464   GThreadedResolverRequest *req;
 465   gchar *name;
 466
 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);
 470
 471   name = req->u.address.name;
 472   g_threaded_resolver_request_unref (req);
 473   return name;
 474 }
 475
 476 static void
 477 free_lookup_by_address (GThreadedResolverRequest *req)
 478 {
 479   g_object_unref (req->u.address.address);
 480   if (req->u.address.name)
 481     g_free (req->u.address.name);
 482 }
 483
 484 static void
 485 lookup_by_address_async (GResolver           *resolver,
 486                          GInetAddress        *address,
 487                          GCancellable        *cancellable,
 488                          GAsyncReadyCallback  callback,
 489                          gpointer             user_data)
 490 {
 491   GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
 492   GThreadedResolverRequest *req;
 493
 494   req = g_threaded_resolver_request_new (do_lookup_by_address,
 495                                          free_lookup_by_address,
 496                                          cancellable);
 497   req->u.address.address = g_object_ref (address);
 498   resolve_async (gtr, req, callback, user_data, lookup_by_address_async);
 499 }
 500
 501 static gchar *
 502 lookup_by_address_finish (GResolver     *resolver,
 503                           GAsyncResult  *result,
 504                           GError       **error)
 505 {
 506   GThreadedResolverRequest *req;
 507   gchar *name;
 508
 509   req = resolve_finish (resolver, result, lookup_by_address_async, error);
 510   name = req->u.address.name;
 511   req->u.address.name = NULL;
 512   return name;
 513 }
 514
 515
 516 static void
 517 do_lookup_service (GThreadedResolverRequest *req,
 518                    GError   **error)
 519 {
 520 #if defined(G_OS_UNIX)
 521   gint len, herr;
 522   guchar answer[1024];
 523 #elif defined(G_OS_WIN32)
 524   DNS_STATUS status;
 525   DNS_RECORD *results;
 526 #endif
 527
 528 #if defined(G_OS_UNIX)
 529   len = res_query (req->u.service.rrname, C_IN, T_SRV, answer, sizeof (answer));
 530   herr = h_errno;
 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);
 537 #endif
 538 }
 539
 540 static GList *
 541 lookup_service (GResolver        *resolver,
 542                 const gchar      *rrname,
 543                 GCancellable     *cancellable,
 544                 GError          **error)
 545 {
 546   GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
 547   GThreadedResolverRequest *req;
 548   GList *targets;
 549
 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);
 553
 554   targets = req->u.service.targets;
 555   g_threaded_resolver_request_unref (req);
 556   return targets;
 557 }
 558
 559 static void
 560 free_lookup_service (GThreadedResolverRequest *req)
 561 {
 562   g_free (req->u.service.rrname);
 563   if (req->u.service.targets)
 564     g_resolver_free_targets (req->u.service.targets);
 565 }
 566
 567 static void
 568 lookup_service_async (GResolver           *resolver,
 569                       const char          *rrname,
 570                       GCancellable        *cancellable,
 571                       GAsyncReadyCallback  callback,
 572                       gpointer             user_data)
 573 {
 574   GThreadedResolver *gtr = G_THREADED_RESOLVER (resolver);
 575   GThreadedResolverRequest *req;
 576
 577   req = g_threaded_resolver_request_new (do_lookup_service,
 578                                          free_lookup_service,
 579                                          cancellable);
 580   req->u.service.rrname = g_strdup (rrname);
 581   resolve_async (gtr, req, callback, user_data, lookup_service_async);
 582 }
 583
 584 static GList *
 585 lookup_service_finish (GResolver     *resolver,
 586                        GAsyncResult  *result,
 587                        GError       **error)
 588 {
 589   GThreadedResolverRequest *req;
 590   GList *targets;
 591
 592   req = resolve_finish (resolver, result, lookup_service_async, error);
 593   targets = req->u.service.targets;
 594   req->u.service.targets = NULL;
 595   return targets;
 596 }
 597
 598
 599 static void
 600 g_threaded_resolver_class_init (GThreadedResolverClass *threaded_class)
 601 {
 602   GResolverClass *resolver_class = G_RESOLVER_CLASS (threaded_class);
 603   GObjectClass *object_class = G_OBJECT_CLASS (threaded_class);
 604
 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;
 614
 615   object_class->finalize = finalize;
 616 }