gio/gdbusinterfaceskeleton.c

   1 /* GDBus - GLib D-Bus Library
   2  *
   3  * Copyright (C) 2008-2010 Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
  17  *
  18  * Author: David Zeuthen <davidz@redhat.com>
  19  */
  20
  21 #include "config.h"
  22
  23 #include "gdbusinterface.h"
  24 #include "gdbusinterfaceskeleton.h"
  25 #include "gdbusobjectskeleton.h"
  26 #include "gioenumtypes.h"
  27 #include "gdbusprivate.h"
  28 #include "gdbusmethodinvocation.h"
  29 #include "gdbusconnection.h"
  30 #include "gtask.h"
  31 #include "gioerror.h"
  32
  33 #include "glibintl.h"
  34
  35 /**
  36  * SECTION:gdbusinterfaceskeleton
  37  * @short_description: Service-side D-Bus interface
  38  * @include: gio/gio.h
  39  *
  40  * Abstract base class for D-Bus interfaces on the service side.
  41  */
  42
  43 struct _GDBusInterfaceSkeletonPrivate
  44 {
  45   GMutex                      lock;
  46
  47   GDBusObject                *object;
  48   GDBusInterfaceSkeletonFlags flags;
  49
  50   GSList                     *connections;   /* List of ConnectionData */
  51   gchar                      *object_path;   /* The object path for this skeleton */
  52   GDBusInterfaceVTable       *hooked_vtable;
  53 };
  54
  55 typedef struct
  56 {
  57   GDBusConnection *connection;
  58   guint            registration_id;
  59 } ConnectionData;
  60
  61 enum
  62 {
  63   G_AUTHORIZE_METHOD_SIGNAL,
  64   LAST_SIGNAL
  65 };
  66
  67 enum
  68 {
  69   PROP_0,
  70   PROP_G_FLAGS
  71 };
  72
  73 static guint signals[LAST_SIGNAL] = {0};
  74
  75 static void     dbus_interface_interface_init                      (GDBusInterfaceIface    *iface);
  76
  77 static void     set_object_path_locked                             (GDBusInterfaceSkeleton *interface_,
  78                                                                     const gchar            *object_path);
  79 static void     remove_connection_locked                           (GDBusInterfaceSkeleton *interface_,
  80                                                                     GDBusConnection        *connection);
  81 static void     skeleton_intercept_handle_method_call              (GDBusConnection        *connection,
  82                                                                     const gchar            *sender,
  83                                                                     const gchar            *object_path,
  84                                                                     const gchar            *interface_name,
  85                                                                     const gchar            *method_name,
  86                                                                     GVariant               *parameters,
  87                                                                     GDBusMethodInvocation  *invocation,
  88                                                                     gpointer                user_data);
  89
  90
  91 G_DEFINE_ABSTRACT_TYPE_WITH_CODE (GDBusInterfaceSkeleton, g_dbus_interface_skeleton, G_TYPE_OBJECT,
  92                                   G_ADD_PRIVATE (GDBusInterfaceSkeleton)
  93                                   G_IMPLEMENT_INTERFACE (G_TYPE_DBUS_INTERFACE, dbus_interface_interface_init))
  94
  95 static void
  96 g_dbus_interface_skeleton_finalize (GObject *object)
  97 {
  98   GDBusInterfaceSkeleton *interface = G_DBUS_INTERFACE_SKELETON (object);
  99
 100   /* Hold the lock just incase any code we call verifies that the lock is held */
 101   g_mutex_lock (&interface->priv->lock);
 102
 103   /* unexport from all connections if we're exported anywhere */
 104   while (interface->priv->connections != NULL)
 105     {
 106       ConnectionData *data = interface->priv->connections->data;
 107       remove_connection_locked (interface, data->connection);
 108     }
 109
 110   set_object_path_locked (interface, NULL);
 111
 112   g_mutex_unlock (&interface->priv->lock);
 113
 114   g_free (interface->priv->hooked_vtable);
 115
 116   if (interface->priv->object != NULL)
 117     g_object_remove_weak_pointer (G_OBJECT (interface->priv->object), (gpointer *) &interface->priv->object);
 118
 119   g_mutex_clear (&interface->priv->lock);
 120
 121   G_OBJECT_CLASS (g_dbus_interface_skeleton_parent_class)->finalize (object);
 122 }
 123
 124 static void
 125 g_dbus_interface_skeleton_get_property (GObject      *object,
 126                                         guint         prop_id,
 127                                         GValue       *value,
 128                                         GParamSpec   *pspec)
 129 {
 130   GDBusInterfaceSkeleton *interface = G_DBUS_INTERFACE_SKELETON (object);
 131
 132   switch (prop_id)
 133     {
 134     case PROP_G_FLAGS:
 135       g_value_set_flags (value, g_dbus_interface_skeleton_get_flags (interface));
 136       break;
 137
 138     default:
 139       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 140       break;
 141     }
 142 }
 143
 144 static void
 145 g_dbus_interface_skeleton_set_property (GObject      *object,
 146                                         guint         prop_id,
 147                                         const GValue *value,
 148                                         GParamSpec   *pspec)
 149 {
 150   GDBusInterfaceSkeleton *interface = G_DBUS_INTERFACE_SKELETON (object);
 151
 152   switch (prop_id)
 153     {
 154     case PROP_G_FLAGS:
 155       g_dbus_interface_skeleton_set_flags (interface, g_value_get_flags (value));
 156       break;
 157
 158     default:
 159       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 160       break;
 161     }
 162 }
 163
 164 static gboolean
 165 g_dbus_interface_skeleton_g_authorize_method_default (GDBusInterfaceSkeleton    *interface,
 166                                                       GDBusMethodInvocation *invocation)
 167 {
 168   return TRUE;
 169 }
 170
 171 static void
 172 g_dbus_interface_skeleton_class_init (GDBusInterfaceSkeletonClass *klass)
 173 {
 174   GObjectClass *gobject_class;
 175
 176   gobject_class = G_OBJECT_CLASS (klass);
 177   gobject_class->finalize     = g_dbus_interface_skeleton_finalize;
 178   gobject_class->set_property = g_dbus_interface_skeleton_set_property;
 179   gobject_class->get_property = g_dbus_interface_skeleton_get_property;
 180
 181   klass->g_authorize_method = g_dbus_interface_skeleton_g_authorize_method_default;
 182
 183   /**
 184    * GDBusInterfaceSkeleton:g-flags:
 185    *
 186    * Flags from the #GDBusInterfaceSkeletonFlags enumeration.
 187    *
 188    * Since: 2.30
 189    */
 190   g_object_class_install_property (gobject_class,
 191                                    PROP_G_FLAGS,
 192                                    g_param_spec_flags ("g-flags",
 193                                                        "g-flags",
 194                                                        "Flags for the interface skeleton",
 195                                                        G_TYPE_DBUS_INTERFACE_SKELETON_FLAGS,
 196                                                        G_DBUS_INTERFACE_SKELETON_FLAGS_NONE,
 197                                                        G_PARAM_READABLE |
 198                                                        G_PARAM_WRITABLE |
 199                                                        G_PARAM_STATIC_STRINGS));
 200
 201   /**
 202    * GDBusInterfaceSkeleton::g-authorize-method:
 203    * @interface: The #GDBusInterfaceSkeleton emitting the signal.
 204    * @invocation: A #GDBusMethodInvocation.
 205    *
 206    * Emitted when a method is invoked by a remote caller and used to
 207    * determine if the method call is authorized.
 208    *
 209    * Note that this signal is emitted in a thread dedicated to
 210    * handling the method call so handlers are allowed to perform
 211    * blocking IO. This means that it is appropriate to call e.g.
 212    * [polkit_authority_check_authorization_sync()](http://hal.freedesktop.org/docs/polkit/PolkitAuthority.html#polkit-authority-check-authorization-sync)
 213    * with the
 214    * [POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION](http://hal.freedesktop.org/docs/polkit/PolkitAuthority.html#POLKIT-CHECK-AUTHORIZATION-FLAGS-ALLOW-USER-INTERACTION:CAPS)
 215    * flag set.
 216    *
 217    * If %FALSE is returned then no further handlers are run and the
 218    * signal handler must take a reference to @invocation and finish
 219    * handling the call (e.g. return an error via
 220    * g_dbus_method_invocation_return_error()).
 221    *
 222    * Otherwise, if %TRUE is returned, signal emission continues. If no
 223    * handlers return %FALSE, then the method is dispatched. If
 224    * @interface has an enclosing #GDBusObjectSkeleton, then the
 225    * #GDBusObjectSkeleton::authorize-method signal handlers run before
 226    * the handlers for this signal.
 227    *
 228    * The default class handler just returns %TRUE.
 229    *
 230    * Please note that the common case is optimized: if no signals
 231    * handlers are connected and the default class handler isn't
 232    * overridden (for both @interface and the enclosing
 233    * #GDBusObjectSkeleton, if any) and #GDBusInterfaceSkeleton:g-flags does
 234    * not have the
 235    * %G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD
 236    * flags set, no dedicated thread is ever used and the call will be
 237    * handled in the same thread as the object that @interface belongs
 238    * to was exported in.
 239    *
 240    * Returns: %TRUE if the call is authorized, %FALSE otherwise.
 241    *
 242    * Since: 2.30
 243    */
 244   signals[G_AUTHORIZE_METHOD_SIGNAL] =
 245     g_signal_new ("g-authorize-method",
 246                   G_TYPE_DBUS_INTERFACE_SKELETON,
 247                   G_SIGNAL_RUN_LAST,
 248                   G_STRUCT_OFFSET (GDBusInterfaceSkeletonClass, g_authorize_method),
 249                   _g_signal_accumulator_false_handled,
 250                   NULL,
 251                   NULL,
 252                   G_TYPE_BOOLEAN,
 253                   1,
 254                   G_TYPE_DBUS_METHOD_INVOCATION);
 255 }
 256
 257 static void
 258 g_dbus_interface_skeleton_init (GDBusInterfaceSkeleton *interface)
 259 {
 260   interface->priv = g_dbus_interface_skeleton_get_instance_private (interface);
 261   g_mutex_init (&interface->priv->lock);
 262 }
 263
 264 /* ---------------------------------------------------------------------------------------------------- */
 265
 266 /**
 267  * g_dbus_interface_skeleton_get_flags:
 268  * @interface_: A #GDBusInterfaceSkeleton.
 269  *
 270  * Gets the #GDBusInterfaceSkeletonFlags that describes what the behavior
 271  * of @interface_
 272  *
 273  * Returns: One or more flags from the #GDBusInterfaceSkeletonFlags enumeration.
 274  *
 275  * Since: 2.30
 276  */
 277 GDBusInterfaceSkeletonFlags
 278 g_dbus_interface_skeleton_get_flags (GDBusInterfaceSkeleton  *interface_)
 279 {
 280   g_return_val_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_), G_DBUS_INTERFACE_SKELETON_FLAGS_NONE);
 281   return interface_->priv->flags;
 282 }
 283
 284 /**
 285  * g_dbus_interface_skeleton_set_flags:
 286  * @interface_: A #GDBusInterfaceSkeleton.
 287  * @flags: Flags from the #GDBusInterfaceSkeletonFlags enumeration.
 288  *
 289  * Sets flags describing what the behavior of @skeleton should be.
 290  *
 291  * Since: 2.30
 292  */
 293 void
 294 g_dbus_interface_skeleton_set_flags (GDBusInterfaceSkeleton      *interface_,
 295                                      GDBusInterfaceSkeletonFlags  flags)
 296 {
 297   g_return_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_));
 298   g_mutex_lock (&interface_->priv->lock);
 299   if (interface_->priv->flags != flags)
 300     {
 301       interface_->priv->flags = flags;
 302       g_mutex_unlock (&interface_->priv->lock);
 303       g_object_notify (G_OBJECT (interface_), "g-flags");
 304     }
 305   else
 306     {
 307       g_mutex_unlock (&interface_->priv->lock);
 308     }
 309 }
 310
 311 /**
 312  * g_dbus_interface_skeleton_get_info:
 313  * @interface_: A #GDBusInterfaceSkeleton.
 314  *
 315  * Gets D-Bus introspection information for the D-Bus interface
 316  * implemented by @interface_.
 317  *
 318  * Returns: (transfer none): A #GDBusInterfaceInfo (never %NULL). Do not free.
 319  *
 320  * Since: 2.30
 321  */
 322 GDBusInterfaceInfo *
 323 g_dbus_interface_skeleton_get_info (GDBusInterfaceSkeleton *interface_)
 324 {
 325   GDBusInterfaceInfo *ret;
 326   g_return_val_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_), NULL);
 327   ret = G_DBUS_INTERFACE_SKELETON_GET_CLASS (interface_)->get_info (interface_);
 328   g_warn_if_fail (ret != NULL);
 329   return ret;
 330 }
 331
 332 /**
 333  * g_dbus_interface_skeleton_get_vtable: (skip)
 334  * @interface_: A #GDBusInterfaceSkeleton.
 335  *
 336  * Gets the interface vtable for the D-Bus interface implemented by
 337  * @interface_. The returned function pointers should expect @interface_
 338  * itself to be passed as @user_data.
 339  *
 340  * Returns: A #GDBusInterfaceVTable (never %NULL).
 341  *
 342  * Since: 2.30
 343  */
 344 GDBusInterfaceVTable *
 345 g_dbus_interface_skeleton_get_vtable (GDBusInterfaceSkeleton *interface_)
 346 {
 347   GDBusInterfaceVTable *ret;
 348   g_return_val_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_), NULL);
 349   ret = G_DBUS_INTERFACE_SKELETON_GET_CLASS (interface_)->get_vtable (interface_);
 350   g_warn_if_fail (ret != NULL);
 351   return ret;
 352 }
 353
 354 /**
 355  * g_dbus_interface_skeleton_get_properties:
 356  * @interface_: A #GDBusInterfaceSkeleton.
 357  *
 358  * Gets all D-Bus properties for @interface_.
 359  *
 360  * Returns: (transfer full): A #GVariant of type
 361  * ['a{sv}'][G-VARIANT-TYPE-VARDICT:CAPS].
 362  * Free with g_variant_unref().
 363  *
 364  * Since: 2.30
 365  */
 366 GVariant *
 367 g_dbus_interface_skeleton_get_properties (GDBusInterfaceSkeleton *interface_)
 368 {
 369   GVariant *ret;
 370   g_return_val_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_), NULL);
 371   ret = G_DBUS_INTERFACE_SKELETON_GET_CLASS (interface_)->get_properties (interface_);
 372   return g_variant_take_ref (ret);
 373 }
 374
 375 /**
 376  * g_dbus_interface_skeleton_flush:
 377  * @interface_: A #GDBusInterfaceSkeleton.
 378  *
 379  * If @interface_ has outstanding changes, request for these changes to be
 380  * emitted immediately.
 381  *
 382  * For example, an exported D-Bus interface may queue up property
 383  * changes and emit the
 384  * `org.freedesktop.DBus.Properties::Propert``
 385  * signal later (e.g. in an idle handler). This technique is useful
 386  * for collapsing multiple property changes into one.
 387  *
 388  * Since: 2.30
 389  */
 390 void
 391 g_dbus_interface_skeleton_flush (GDBusInterfaceSkeleton *interface_)
 392 {
 393   g_return_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_));
 394   G_DBUS_INTERFACE_SKELETON_GET_CLASS (interface_)->flush (interface_);
 395 }
 396
 397 /* ---------------------------------------------------------------------------------------------------- */
 398
 399 static GDBusInterfaceInfo *
 400 _g_dbus_interface_skeleton_get_info (GDBusInterface *interface_)
 401 {
 402   GDBusInterfaceSkeleton *interface = G_DBUS_INTERFACE_SKELETON (interface_);
 403   return g_dbus_interface_skeleton_get_info (interface);
 404 }
 405
 406 static GDBusObject *
 407 g_dbus_interface_skeleton_get_object (GDBusInterface *interface_)
 408 {
 409   GDBusInterfaceSkeleton *interface = G_DBUS_INTERFACE_SKELETON (interface_);
 410   GDBusObject *ret;
 411   g_mutex_lock (&interface->priv->lock);
 412   ret = interface->priv->object;
 413   g_mutex_unlock (&interface->priv->lock);
 414   return ret;
 415 }
 416
 417 static GDBusObject *
 418 g_dbus_interface_skeleton_dup_object (GDBusInterface *interface_)
 419 {
 420   GDBusInterfaceSkeleton *interface = G_DBUS_INTERFACE_SKELETON (interface_);
 421   GDBusObject *ret;
 422   g_mutex_lock (&interface->priv->lock);
 423   ret = interface->priv->object;
 424   if (ret != NULL)
 425     g_object_ref (ret);
 426   g_mutex_unlock (&interface->priv->lock);
 427   return ret;
 428 }
 429
 430 static void
 431 g_dbus_interface_skeleton_set_object (GDBusInterface *interface_,
 432                                       GDBusObject    *object)
 433 {
 434   GDBusInterfaceSkeleton *interface = G_DBUS_INTERFACE_SKELETON (interface_);
 435   g_mutex_lock (&interface->priv->lock);
 436   if (interface->priv->object != NULL)
 437     g_object_remove_weak_pointer (G_OBJECT (interface->priv->object), (gpointer *) &interface->priv->object);
 438   interface->priv->object = object;
 439   if (object != NULL)
 440     g_object_add_weak_pointer (G_OBJECT (interface->priv->object), (gpointer *) &interface->priv->object);
 441   g_mutex_unlock (&interface->priv->lock);
 442 }
 443
 444 static void
 445 dbus_interface_interface_init (GDBusInterfaceIface *iface)
 446 {
 447   iface->get_info    = _g_dbus_interface_skeleton_get_info;
 448   iface->get_object  = g_dbus_interface_skeleton_get_object;
 449   iface->dup_object  = g_dbus_interface_skeleton_dup_object;
 450   iface->set_object  = g_dbus_interface_skeleton_set_object;
 451 }
 452
 453 /* ---------------------------------------------------------------------------------------------------- */
 454
 455 typedef struct
 456 {
 457   volatile gint ref_count;
 458   GDBusInterfaceSkeleton       *interface;
 459   GDBusInterfaceMethodCallFunc  method_call_func;
 460   GDBusMethodInvocation        *invocation;
 461 } DispatchData;
 462
 463 static void
 464 dispatch_data_unref (DispatchData *data)
 465 {
 466   if (g_atomic_int_dec_and_test (&data->ref_count))
 467     g_slice_free (DispatchData, data);
 468 }
 469
 470 static DispatchData *
 471 dispatch_data_ref (DispatchData *data)
 472 {
 473   g_atomic_int_inc (&data->ref_count);
 474   return data;
 475 }
 476
 477 static gboolean
 478 dispatch_invoke_in_context_func (gpointer user_data)
 479 {
 480   DispatchData *data = user_data;
 481   data->method_call_func (g_dbus_method_invocation_get_connection (data->invocation),
 482                           g_dbus_method_invocation_get_sender (data->invocation),
 483                           g_dbus_method_invocation_get_object_path (data->invocation),
 484                           g_dbus_method_invocation_get_interface_name (data->invocation),
 485                           g_dbus_method_invocation_get_method_name (data->invocation),
 486                           g_dbus_method_invocation_get_parameters (data->invocation),
 487                           data->invocation,
 488                           g_dbus_method_invocation_get_user_data (data->invocation));
 489   return FALSE;
 490 }
 491
 492 static void
 493 dispatch_in_thread_func (GTask        *task,
 494                          gpointer      source_object,
 495                          gpointer      task_data,
 496                          GCancellable *cancellable)
 497 {
 498   DispatchData *data = task_data;
 499   GDBusInterfaceSkeletonFlags flags;
 500   GDBusObject *object;
 501   gboolean authorized;
 502
 503   g_mutex_lock (&data->interface->priv->lock);
 504   flags = data->interface->priv->flags;
 505   object = data->interface->priv->object;
 506   if (object != NULL)
 507     g_object_ref (object);
 508   g_mutex_unlock (&data->interface->priv->lock);
 509
 510   /* first check on the enclosing object (if any), then the interface */
 511   authorized = TRUE;
 512   if (object != NULL)
 513     {
 514       g_signal_emit_by_name (object,
 515                              "authorize-method",
 516                              data->interface,
 517                              data->invocation,
 518                              &authorized);
 519     }
 520   if (authorized)
 521     {
 522       g_signal_emit (data->interface,
 523                      signals[G_AUTHORIZE_METHOD_SIGNAL],
 524                      0,
 525                      data->invocation,
 526                      &authorized);
 527     }
 528
 529   if (authorized)
 530     {
 531       gboolean run_in_thread;
 532       run_in_thread = (flags & G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD);
 533       if (run_in_thread)
 534         {
 535           /* might as well just re-use the existing thread */
 536           data->method_call_func (g_dbus_method_invocation_get_connection (data->invocation),
 537                                   g_dbus_method_invocation_get_sender (data->invocation),
 538                                   g_dbus_method_invocation_get_object_path (data->invocation),
 539                                   g_dbus_method_invocation_get_interface_name (data->invocation),
 540                                   g_dbus_method_invocation_get_method_name (data->invocation),
 541                                   g_dbus_method_invocation_get_parameters (data->invocation),
 542                                   data->invocation,
 543                                   g_dbus_method_invocation_get_user_data (data->invocation));
 544         }
 545       else
 546         {
 547           /* bah, back to original context */
 548           g_main_context_invoke_full (g_task_get_context (task),
 549                                       g_task_get_priority (task),
 550                                       dispatch_invoke_in_context_func,
 551                                       dispatch_data_ref (data),
 552                                       (GDestroyNotify) dispatch_data_unref);
 553         }
 554     }
 555   else
 556     {
 557       /* do nothing */
 558     }
 559
 560   if (object != NULL)
 561     g_object_unref (object);
 562 }
 563
 564 static void
 565 g_dbus_interface_method_dispatch_helper (GDBusInterfaceSkeleton       *interface,
 566                                          GDBusInterfaceMethodCallFunc  method_call_func,
 567                                          GDBusMethodInvocation        *invocation)
 568 {
 569   gboolean has_handlers;
 570   gboolean has_default_class_handler;
 571   gboolean emit_authorized_signal;
 572   gboolean run_in_thread;
 573   GDBusInterfaceSkeletonFlags flags;
 574   GDBusObject *object;
 575
 576   g_return_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface));
 577   g_return_if_fail (method_call_func != NULL);
 578   g_return_if_fail (G_IS_DBUS_METHOD_INVOCATION (invocation));
 579
 580   g_mutex_lock (&interface->priv->lock);
 581   flags = interface->priv->flags;
 582   object = interface->priv->object;
 583   if (object != NULL)
 584     g_object_ref (object);
 585   g_mutex_unlock (&interface->priv->lock);
 586
 587   /* optimization for the common case where
 588    *
 589    *  a) no handler is connected and class handler is not overridden (both interface and object); and
 590    *  b) method calls are not dispatched in a thread
 591    */
 592   has_handlers = g_signal_has_handler_pending (interface,
 593                                                signals[G_AUTHORIZE_METHOD_SIGNAL],
 594                                                0,
 595                                                TRUE);
 596   has_default_class_handler = (G_DBUS_INTERFACE_SKELETON_GET_CLASS (interface)->g_authorize_method ==
 597                                g_dbus_interface_skeleton_g_authorize_method_default);
 598
 599   emit_authorized_signal = (has_handlers || !has_default_class_handler);
 600   if (!emit_authorized_signal)
 601     {
 602       if (object != NULL)
 603         emit_authorized_signal = _g_dbus_object_skeleton_has_authorize_method_handlers (G_DBUS_OBJECT_SKELETON (object));
 604     }
 605
 606   run_in_thread = (flags & G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD);
 607   if (!emit_authorized_signal && !run_in_thread)
 608     {
 609       method_call_func (g_dbus_method_invocation_get_connection (invocation),
 610                         g_dbus_method_invocation_get_sender (invocation),
 611                         g_dbus_method_invocation_get_object_path (invocation),
 612                         g_dbus_method_invocation_get_interface_name (invocation),
 613                         g_dbus_method_invocation_get_method_name (invocation),
 614                         g_dbus_method_invocation_get_parameters (invocation),
 615                         invocation,
 616                         g_dbus_method_invocation_get_user_data (invocation));
 617     }
 618   else
 619     {
 620       GTask *task;
 621       DispatchData *data;
 622
 623       data = g_slice_new0 (DispatchData);
 624       data->interface = interface;
 625       data->method_call_func = method_call_func;
 626       data->invocation = invocation;
 627       data->ref_count = 1;
 628
 629       task = g_task_new (interface, NULL, NULL, NULL);
 630       g_task_set_task_data (task, data, (GDestroyNotify) dispatch_data_unref);
 631       g_task_run_in_thread (task, dispatch_in_thread_func);
 632       g_object_unref (task);
 633     }
 634
 635   if (object != NULL)
 636     g_object_unref (object);
 637 }
 638
 639 static void
 640 skeleton_intercept_handle_method_call (GDBusConnection       *connection,
 641                                        const gchar           *sender,
 642                                        const gchar           *object_path,
 643                                        const gchar           *interface_name,
 644                                        const gchar           *method_name,
 645                                        GVariant              *parameters,
 646                                        GDBusMethodInvocation *invocation,
 647                                        gpointer               user_data)
 648 {
 649   GDBusInterfaceSkeleton *interface = G_DBUS_INTERFACE_SKELETON (user_data);
 650   g_dbus_interface_method_dispatch_helper (interface,
 651                                            g_dbus_interface_skeleton_get_vtable (interface)->method_call,
 652                                            invocation);
 653 }
 654
 655 /* ---------------------------------------------------------------------------------------------------- */
 656
 657 static ConnectionData *
 658 new_connection (GDBusConnection *connection,
 659                 guint            registration_id)
 660 {
 661   ConnectionData *data;
 662
 663   data = g_slice_new0 (ConnectionData);
 664   data->connection      = g_object_ref (connection);
 665   data->registration_id = registration_id;
 666
 667   return data;
 668 }
 669
 670 static void
 671 free_connection (ConnectionData *data)
 672 {
 673   if (data != NULL)
 674     {
 675       g_object_unref (data->connection);
 676       g_slice_free (ConnectionData, data);
 677     }
 678 }
 679
 680 static gboolean
 681 add_connection_locked (GDBusInterfaceSkeleton *interface_,
 682                        GDBusConnection        *connection,
 683                        GError                **error)
 684 {
 685   ConnectionData *data;
 686   guint registration_id;
 687   gboolean ret = FALSE;
 688
 689   if (interface_->priv->hooked_vtable == NULL)
 690     {
 691       /* Hook the vtable since we need to intercept method calls for
 692        * ::g-authorize-method and for dispatching in thread vs
 693        * context
 694        *
 695        * We need to wait until subclasses have had time to initialize
 696        * properly before building the hooked_vtable, so we create it
 697        * once at the last minute.
 698        */
 699       interface_->priv->hooked_vtable = g_memdup (g_dbus_interface_skeleton_get_vtable (interface_), sizeof (GDBusInterfaceVTable));
 700       interface_->priv->hooked_vtable->method_call = skeleton_intercept_handle_method_call;
 701     }
 702
 703   registration_id = g_dbus_connection_register_object (connection,
 704                                                        interface_->priv->object_path,
 705                                                        g_dbus_interface_skeleton_get_info (interface_),
 706                                                        interface_->priv->hooked_vtable,
 707                                                        interface_,
 708                                                        NULL, /* user_data_free_func */
 709                                                        error);
 710
 711   if (registration_id > 0)
 712     {
 713       data = new_connection (connection, registration_id);
 714       interface_->priv->connections = g_slist_append (interface_->priv->connections, data);
 715       ret = TRUE;
 716     }
 717
 718   return ret;
 719 }
 720
 721 static void
 722 remove_connection_locked (GDBusInterfaceSkeleton *interface_,
 723                           GDBusConnection        *connection)
 724 {
 725   ConnectionData *data;
 726   GSList *l;
 727
 728   /* Get the connection in the list and unregister ... */
 729   for (l = interface_->priv->connections; l != NULL; l = l->next)
 730     {
 731       data = l->data;
 732       if (data->connection == connection)
 733         {
 734           g_warn_if_fail (g_dbus_connection_unregister_object (data->connection, data->registration_id));
 735           free_connection (data);
 736           interface_->priv->connections = g_slist_delete_link (interface_->priv->connections, l);
 737           /* we are guaranteed that the connection is only added once, so bail out early */
 738           goto out;
 739         }
 740     }
 741  out:
 742   ;
 743 }
 744
 745 static void
 746 set_object_path_locked (GDBusInterfaceSkeleton *interface_,
 747                         const gchar            *object_path)
 748 {
 749   if (g_strcmp0 (interface_->priv->object_path, object_path) != 0)
 750     {
 751       g_free (interface_->priv->object_path);
 752       interface_->priv->object_path = g_strdup (object_path);
 753     }
 754 }
 755
 756 /* ---------------------------------------------------------------------------------------------------- */
 757
 758 /**
 759  * g_dbus_interface_skeleton_get_connection:
 760  * @interface_: A #GDBusInterfaceSkeleton.
 761  *
 762  * Gets the first connection that @interface_ is exported on, if any.
 763  *
 764  * Returns: (transfer none): A #GDBusConnection or %NULL if @interface_ is
 765  * not exported anywhere. Do not free, the object belongs to @interface_.
 766  *
 767  * Since: 2.30
 768  */
 769 GDBusConnection *
 770 g_dbus_interface_skeleton_get_connection (GDBusInterfaceSkeleton *interface_)
 771 {
 772   ConnectionData  *data;
 773   GDBusConnection *ret;
 774
 775   g_return_val_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_), NULL);
 776   g_mutex_lock (&interface_->priv->lock);
 777
 778   ret = NULL;
 779   if (interface_->priv->connections != NULL)
 780     {
 781       data = interface_->priv->connections->data;
 782       if (data != NULL)
 783         ret = data->connection;
 784     }
 785
 786   g_mutex_unlock (&interface_->priv->lock);
 787
 788   return ret;
 789 }
 790
 791 /**
 792  * g_dbus_interface_skeleton_get_connections:
 793  * @interface_: A #GDBusInterfaceSkeleton.
 794  *
 795  * Gets a list of the connections that @interface_ is exported on.
 796  *
 797  * Returns: (element-type GDBusConnection) (transfer full): A list of
 798  *   all the connections that @interface_ is exported on. The returned
 799  *   list should be freed with g_list_free() after each element has
 800  *   been freed with g_object_unref().
 801  *
 802  * Since: 2.32
 803  */
 804 GList *
 805 g_dbus_interface_skeleton_get_connections (GDBusInterfaceSkeleton *interface_)
 806 {
 807   GList           *connections;
 808   GSList          *l;
 809   ConnectionData  *data;
 810
 811   g_return_val_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_), NULL);
 812
 813   g_mutex_lock (&interface_->priv->lock);
 814   connections = NULL;
 815
 816   for (l = interface_->priv->connections; l != NULL; l = l->next)
 817     {
 818       data        = l->data;
 819       connections = g_list_prepend (connections,
 820                                     /* Return a reference to each connection */
 821                                     g_object_ref (data->connection));
 822     }
 823
 824   g_mutex_unlock (&interface_->priv->lock);
 825
 826   return g_list_reverse (connections);
 827 }
 828
 829 /**
 830  * g_dbus_interface_skeleton_has_connection:
 831  * @interface_: A #GDBusInterfaceSkeleton.
 832  * @connection: A #GDBusConnection.
 833  *
 834  * Checks if @interface_ is exported on @connection.
 835  *
 836  * Returns: %TRUE if @interface_ is exported on @connection, %FALSE otherwise.
 837  *
 838  * Since: 2.32
 839  */
 840 gboolean
 841 g_dbus_interface_skeleton_has_connection (GDBusInterfaceSkeleton     *interface_,
 842                                           GDBusConnection            *connection)
 843 {
 844   GSList *l;
 845   gboolean ret = FALSE;
 846
 847   g_return_val_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_), FALSE);
 848   g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), FALSE);
 849
 850   g_mutex_lock (&interface_->priv->lock);
 851
 852   for (l = interface_->priv->connections; l != NULL; l = l->next)
 853     {
 854       ConnectionData *data = l->data;
 855       if (data->connection == connection)
 856         {
 857           ret = TRUE;
 858           goto out;
 859         }
 860     }
 861
 862  out:
 863   g_mutex_unlock (&interface_->priv->lock);
 864   return ret;
 865 }
 866
 867 /**
 868  * g_dbus_interface_skeleton_get_object_path:
 869  * @interface_: A #GDBusInterfaceSkeleton.
 870  *
 871  * Gets the object path that @interface_ is exported on, if any.
 872  *
 873  * Returns: A string owned by @interface_ or %NULL if @interface_ is not exported
 874  * anywhere. Do not free, the string belongs to @interface_.
 875  *
 876  * Since: 2.30
 877  */
 878 const gchar *
 879 g_dbus_interface_skeleton_get_object_path (GDBusInterfaceSkeleton *interface_)
 880 {
 881   const gchar *ret;
 882   g_return_val_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_), NULL);
 883   g_mutex_lock (&interface_->priv->lock);
 884   ret = interface_->priv->object_path;
 885   g_mutex_unlock (&interface_->priv->lock);
 886   return ret;
 887 }
 888
 889 /**
 890  * g_dbus_interface_skeleton_export:
 891  * @interface_: The D-Bus interface to export.
 892  * @connection: A #GDBusConnection to export @interface_ on.
 893  * @object_path: The path to export the interface at.
 894  * @error: Return location for error or %NULL.
 895  *
 896  * Exports @interface_ at @object_path on @connection.
 897  *
 898  * This can be called multiple times to export the same @interface_
 899  * onto multiple connections however the @object_path provided must be
 900  * the same for all connections.
 901  *
 902  * Use g_dbus_interface_skeleton_unexport() to unexport the object.
 903  *
 904  * Returns: %TRUE if the interface was exported on @connection, otherwise %FALSE with
 905  * @error set.
 906  *
 907  * Since: 2.30
 908  */
 909 gboolean
 910 g_dbus_interface_skeleton_export (GDBusInterfaceSkeleton  *interface_,
 911                                   GDBusConnection         *connection,
 912                                   const gchar             *object_path,
 913                                   GError                 **error)
 914 {
 915   gboolean ret = FALSE;
 916
 917   g_return_val_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_), FALSE);
 918   g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), FALSE);
 919   g_return_val_if_fail (g_variant_is_object_path (object_path), FALSE);
 920   g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 921
 922   /* Assert that the object path is the same for multiple connections here */
 923   g_return_val_if_fail (interface_->priv->object_path == NULL ||
 924                         g_strcmp0 (interface_->priv->object_path, object_path) == 0, FALSE);
 925
 926   g_mutex_lock (&interface_->priv->lock);
 927
 928   /* Set the object path */
 929   set_object_path_locked (interface_, object_path);
 930
 931   /* Add the connection */
 932   ret = add_connection_locked (interface_, connection, error);
 933
 934   g_mutex_unlock (&interface_->priv->lock);
 935   return ret;
 936 }
 937
 938 /**
 939  * g_dbus_interface_skeleton_unexport:
 940  * @interface_: A #GDBusInterfaceSkeleton.
 941  *
 942  * Stops exporting @interface_ on all connections it is exported on.
 943  *
 944  * To unexport @interface_ from only a single connection, use
 945  * g_dbus_interface_skeleton_unexport_from_connection()
 946  *
 947  * Since: 2.30
 948  */
 949 void
 950 g_dbus_interface_skeleton_unexport (GDBusInterfaceSkeleton *interface_)
 951 {
 952   g_return_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_));
 953   g_return_if_fail (interface_->priv->connections != NULL);
 954
 955   g_mutex_lock (&interface_->priv->lock);
 956
 957   g_assert (interface_->priv->object_path != NULL);
 958   g_assert (interface_->priv->hooked_vtable != NULL);
 959
 960   /* Remove all connections */
 961   while (interface_->priv->connections != NULL)
 962     {
 963       ConnectionData *data = interface_->priv->connections->data;
 964       remove_connection_locked (interface_, data->connection);
 965     }
 966
 967   /* Unset the object path since there are no connections left */
 968   set_object_path_locked (interface_, NULL);
 969
 970   g_mutex_unlock (&interface_->priv->lock);
 971 }
 972
 973
 974 /**
 975  * g_dbus_interface_skeleton_unexport_from_connection:
 976  * @interface_: A #GDBusInterfaceSkeleton.
 977  * @connection: A #GDBusConnection.
 978  *
 979  * Stops exporting @interface_ on @connection.
 980  *
 981  * To stop exporting on all connections the interface is exported on,
 982  * use g_dbus_interface_skeleton_unexport().
 983  *
 984  * Since: 2.32
 985  */
 986 void
 987 g_dbus_interface_skeleton_unexport_from_connection (GDBusInterfaceSkeleton *interface_,
 988                                                     GDBusConnection        *connection)
 989 {
 990   g_return_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_));
 991   g_return_if_fail (G_IS_DBUS_CONNECTION (connection));
 992   g_return_if_fail (interface_->priv->connections != NULL);
 993
 994   g_mutex_lock (&interface_->priv->lock);
 995
 996   g_assert (interface_->priv->object_path != NULL);
 997   g_assert (interface_->priv->hooked_vtable != NULL);
 998
 999   remove_connection_locked (interface_, connection);
1000
1001   /* Reset the object path if we removed the last connection */
1002   if (interface_->priv->connections == NULL)
1003     set_object_path_locked (interface_, NULL);
1004
1005   g_mutex_unlock (&interface_->priv->lock);
1006 }
1007
1008 /* ---------------------------------------------------------------------------------------------------- */