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