gio/gdbusinterfaceskeleton.c

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