0d3df4db9ed2e78200878de49b40c4bd6449dbbd
[platform/upstream/glib.git] / 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, write to the
17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
18  * Boston, MA 02111-1307, USA.
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 "gtask.h"
33 #include "gioerror.h"
34
35 #include "glibintl.h"
36
37 /**
38  * SECTION:gdbusinterfaceskeleton
39  * @short_description: Service-side D-Bus interface
40  * @include: gio/gio.h
41  *
42  * Abstract base class for D-Bus interfaces on the service side.
43  */
44
45 struct _GDBusInterfaceSkeletonPrivate
46 {
47   GMutex                      lock;
48
49   GDBusObject                *object;
50   GDBusInterfaceSkeletonFlags flags;
51
52   GSList                     *connections;   /* List of ConnectionData */
53   gchar                      *object_path;   /* The object path for this skeleton */
54   GDBusInterfaceVTable       *hooked_vtable;
55 };
56
57 typedef struct
58 {
59   GDBusConnection *connection;
60   guint            registration_id;
61 } ConnectionData;
62
63 enum
64 {
65   G_AUTHORIZE_METHOD_SIGNAL,
66   LAST_SIGNAL
67 };
68
69 enum
70 {
71   PROP_0,
72   PROP_G_FLAGS
73 };
74
75 static guint signals[LAST_SIGNAL] = {0};
76
77 static void     dbus_interface_interface_init                      (GDBusInterfaceIface    *iface);
78
79 static void     set_object_path_locked                             (GDBusInterfaceSkeleton *interface_,
80                                                                     const gchar            *object_path);
81 static void     remove_connection_locked                           (GDBusInterfaceSkeleton *interface_,
82                                                                     GDBusConnection        *connection);
83 static void     skeleton_intercept_handle_method_call              (GDBusConnection        *connection,
84                                                                     const gchar            *sender,
85                                                                     const gchar            *object_path,
86                                                                     const gchar            *interface_name,
87                                                                     const gchar            *method_name,
88                                                                     GVariant               *parameters,
89                                                                     GDBusMethodInvocation  *invocation,
90                                                                     gpointer                user_data);
91
92
93 G_DEFINE_ABSTRACT_TYPE_WITH_CODE (GDBusInterfaceSkeleton, g_dbus_interface_skeleton, G_TYPE_OBJECT,
94                                   G_ADD_PRIVATE (GDBusInterfaceSkeleton)
95                                   G_IMPLEMENT_INTERFACE (G_TYPE_DBUS_INTERFACE, dbus_interface_interface_init))
96
97 static void
98 g_dbus_interface_skeleton_finalize (GObject *object)
99 {
100   GDBusInterfaceSkeleton *interface = G_DBUS_INTERFACE_SKELETON (object);
101
102   /* Hold the lock just incase any code we call verifies that the lock is held */
103   g_mutex_lock (&interface->priv->lock);
104
105   /* unexport from all connections if we're exported anywhere */
106   while (interface->priv->connections != NULL)
107     {
108       ConnectionData *data = interface->priv->connections->data;
109       remove_connection_locked (interface, data->connection);
110     }
111
112   set_object_path_locked (interface, NULL);
113
114   g_mutex_unlock (&interface->priv->lock);
115
116   g_free (interface->priv->hooked_vtable);
117
118   if (interface->priv->object != NULL)
119     g_object_remove_weak_pointer (G_OBJECT (interface->priv->object), (gpointer *) &interface->priv->object);
120
121   g_mutex_clear (&interface->priv->lock);
122
123   G_OBJECT_CLASS (g_dbus_interface_skeleton_parent_class)->finalize (object);
124 }
125
126 static void
127 g_dbus_interface_skeleton_get_property (GObject      *object,
128                                         guint         prop_id,
129                                         GValue       *value,
130                                         GParamSpec   *pspec)
131 {
132   GDBusInterfaceSkeleton *interface = G_DBUS_INTERFACE_SKELETON (object);
133
134   switch (prop_id)
135     {
136     case PROP_G_FLAGS:
137       g_value_set_flags (value, g_dbus_interface_skeleton_get_flags (interface));
138       break;
139
140     default:
141       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
142       break;
143     }
144 }
145
146 static void
147 g_dbus_interface_skeleton_set_property (GObject      *object,
148                                         guint         prop_id,
149                                         const GValue *value,
150                                         GParamSpec   *pspec)
151 {
152   GDBusInterfaceSkeleton *interface = G_DBUS_INTERFACE_SKELETON (object);
153
154   switch (prop_id)
155     {
156     case PROP_G_FLAGS:
157       g_dbus_interface_skeleton_set_flags (interface, g_value_get_flags (value));
158       break;
159
160     default:
161       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
162       break;
163     }
164 }
165
166 static gboolean
167 g_dbus_interface_skeleton_g_authorize_method_default (GDBusInterfaceSkeleton    *interface,
168                                                       GDBusMethodInvocation *invocation)
169 {
170   return TRUE;
171 }
172
173 static void
174 g_dbus_interface_skeleton_class_init (GDBusInterfaceSkeletonClass *klass)
175 {
176   GObjectClass *gobject_class;
177
178   gobject_class = G_OBJECT_CLASS (klass);
179   gobject_class->finalize     = g_dbus_interface_skeleton_finalize;
180   gobject_class->set_property = g_dbus_interface_skeleton_set_property;
181   gobject_class->get_property = g_dbus_interface_skeleton_get_property;
182
183   klass->g_authorize_method = g_dbus_interface_skeleton_g_authorize_method_default;
184
185   /**
186    * GDBusInterfaceSkeleton:g-flags:
187    *
188    * Flags from the #GDBusInterfaceSkeletonFlags enumeration.
189    *
190    * Since: 2.30
191    */
192   g_object_class_install_property (gobject_class,
193                                    PROP_G_FLAGS,
194                                    g_param_spec_flags ("g-flags",
195                                                        "g-flags",
196                                                        "Flags for the interface skeleton",
197                                                        G_TYPE_DBUS_INTERFACE_SKELETON_FLAGS,
198                                                        G_DBUS_INTERFACE_SKELETON_FLAGS_NONE,
199                                                        G_PARAM_READABLE |
200                                                        G_PARAM_WRITABLE |
201                                                        G_PARAM_STATIC_STRINGS));
202
203   /**
204    * GDBusInterfaceSkeleton::g-authorize-method:
205    * @interface: The #GDBusInterfaceSkeleton emitting the signal.
206    * @invocation: A #GDBusMethodInvocation.
207    *
208    * Emitted when a method is invoked by a remote caller and used to
209    * determine if the method call is authorized.
210    *
211    * Note that this signal is emitted in a thread dedicated to
212    * handling the method call so handlers are allowed to perform
213    * blocking IO. This means that it is appropriate to call
214    * e.g. <ulink
215    * url="http://hal.freedesktop.org/docs/polkit/PolkitAuthority.html#polkit-authority-check-authorization-sync">polkit_authority_check_authorization_sync()</ulink>
216    * with the <ulink
217    * url="http://hal.freedesktop.org/docs/polkit/PolkitAuthority.html#POLKIT-CHECK-AUTHORIZATION-FLAGS-ALLOW-USER-INTERACTION:CAPS">POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION</ulink> flag set.
218    *
219    * If %FALSE is returned then no further handlers are run and the
220    * signal handler must take a reference to @invocation and finish
221    * handling the call (e.g. return an error via
222    * g_dbus_method_invocation_return_error()).
223    *
224    * Otherwise, if %TRUE is returned, signal emission continues. If no
225    * handlers return %FALSE, then the method is dispatched. If
226    * @interface has an enclosing #GDBusObjectSkeleton, then the
227    * #GDBusObjectSkeleton::authorize-method signal handlers run before
228    * the handlers for this signal.
229    *
230    * The default class handler just returns %TRUE.
231    *
232    * Please note that the common case is optimized: if no signals
233    * handlers are connected and the default class handler isn't
234    * overridden (for both @interface and the enclosing
235    * #GDBusObjectSkeleton, if any) and #GDBusInterfaceSkeleton:g-flags does
236    * not have the
237    * %G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD
238    * flags set, no dedicated thread is ever used and the call will be
239    * handled in the same thread as the object that @interface belongs
240    * to was exported in.
241    *
242    * Returns: %TRUE if the call is authorized, %FALSE otherwise.
243    *
244    * Since: 2.30
245    */
246   signals[G_AUTHORIZE_METHOD_SIGNAL] =
247     g_signal_new ("g-authorize-method",
248                   G_TYPE_DBUS_INTERFACE_SKELETON,
249                   G_SIGNAL_RUN_LAST,
250                   G_STRUCT_OFFSET (GDBusInterfaceSkeletonClass, g_authorize_method),
251                   _g_signal_accumulator_false_handled,
252                   NULL,
253                   NULL,
254                   G_TYPE_BOOLEAN,
255                   1,
256                   G_TYPE_DBUS_METHOD_INVOCATION);
257 }
258
259 static void
260 g_dbus_interface_skeleton_init (GDBusInterfaceSkeleton *interface)
261 {
262   interface->priv = g_dbus_interface_skeleton_get_private (interface);
263   g_mutex_init (&interface->priv->lock);
264 }
265
266 /* ---------------------------------------------------------------------------------------------------- */
267
268 /**
269  * g_dbus_interface_skeleton_get_flags:
270  * @interface_: A #GDBusInterfaceSkeleton.
271  *
272  * Gets the #GDBusInterfaceSkeletonFlags that describes what the behavior
273  * of @interface_
274  *
275  * Returns: One or more flags from the #GDBusInterfaceSkeletonFlags enumeration.
276  *
277  * Since: 2.30
278  */
279 GDBusInterfaceSkeletonFlags
280 g_dbus_interface_skeleton_get_flags (GDBusInterfaceSkeleton  *interface_)
281 {
282   g_return_val_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_), G_DBUS_INTERFACE_SKELETON_FLAGS_NONE);
283   return interface_->priv->flags;
284 }
285
286 /**
287  * g_dbus_interface_skeleton_set_flags:
288  * @interface_: A #GDBusInterfaceSkeleton.
289  * @flags: Flags from the #GDBusInterfaceSkeletonFlags enumeration.
290  *
291  * Sets flags describing what the behavior of @skeleton should be.
292  *
293  * Since: 2.30
294  */
295 void
296 g_dbus_interface_skeleton_set_flags (GDBusInterfaceSkeleton      *interface_,
297                                      GDBusInterfaceSkeletonFlags  flags)
298 {
299   g_return_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_));
300   g_mutex_lock (&interface_->priv->lock);
301   if (interface_->priv->flags != flags)
302     {
303       interface_->priv->flags = flags;
304       g_mutex_unlock (&interface_->priv->lock);
305       g_object_notify (G_OBJECT (interface_), "g-flags");
306     }
307   else
308     {
309       g_mutex_unlock (&interface_->priv->lock);
310     }
311 }
312
313 /**
314  * g_dbus_interface_skeleton_get_info:
315  * @interface_: A #GDBusInterfaceSkeleton.
316  *
317  * Gets D-Bus introspection information for the D-Bus interface
318  * implemented by @interface_.
319  *
320  * Returns: (transfer none): A #GDBusInterfaceInfo (never %NULL). Do not free.
321  *
322  * Since: 2.30
323  */
324 GDBusInterfaceInfo *
325 g_dbus_interface_skeleton_get_info (GDBusInterfaceSkeleton *interface_)
326 {
327   GDBusInterfaceInfo *ret;
328   g_return_val_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_), NULL);
329   ret = G_DBUS_INTERFACE_SKELETON_GET_CLASS (interface_)->get_info (interface_);
330   g_warn_if_fail (ret != NULL);
331   return ret;
332 }
333
334 /**
335  * g_dbus_interface_skeleton_get_vtable: (skip)
336  * @interface_: A #GDBusInterfaceSkeleton.
337  *
338  * Gets the interface vtable for the D-Bus interface implemented by
339  * @interface_. The returned function pointers should expect @interface_
340  * itself to be passed as @user_data.
341  *
342  * Returns: A #GDBusInterfaceVTable (never %NULL).
343  *
344  * Since: 2.30
345  */
346 GDBusInterfaceVTable *
347 g_dbus_interface_skeleton_get_vtable (GDBusInterfaceSkeleton *interface_)
348 {
349   GDBusInterfaceVTable *ret;
350   g_return_val_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_), NULL);
351   ret = G_DBUS_INTERFACE_SKELETON_GET_CLASS (interface_)->get_vtable (interface_);
352   g_warn_if_fail (ret != NULL);
353   return ret;
354 }
355
356 /**
357  * g_dbus_interface_skeleton_get_properties:
358  * @interface_: A #GDBusInterfaceSkeleton.
359  *
360  * Gets all D-Bus properties for @interface_.
361  *
362  * Returns: (transfer full): A #GVariant of type <link linkend="G-VARIANT-TYPE-VARDICT:CAPS">'a{sv}'</link>. 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  * <literal>org.freedesktop.DBus.Properties::PropertiesChanged</literal>
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 /* ---------------------------------------------------------------------------------------------------- */