1 /* GDBus - GLib D-Bus Library
3 * Copyright (C) 2008-2010 Red Hat, Inc.
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.
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.
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/>.
18 * Author: David Zeuthen <davidz@redhat.com>
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"
36 * SECTION:gdbusinterfaceskeleton
37 * @short_description: Service-side D-Bus interface
40 * Abstract base class for D-Bus interfaces on the service side.
43 struct _GDBusInterfaceSkeletonPrivate
48 GDBusInterfaceSkeletonFlags flags;
50 GSList *connections; /* List of ConnectionData */
51 gchar *object_path; /* The object path for this skeleton */
52 GDBusInterfaceVTable *hooked_vtable;
57 GDBusConnection *connection;
58 guint registration_id;
63 G_AUTHORIZE_METHOD_SIGNAL,
73 static guint signals[LAST_SIGNAL] = {0};
75 static void dbus_interface_interface_init (GDBusInterfaceIface *iface);
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,
83 const gchar *object_path,
84 const gchar *interface_name,
85 const gchar *method_name,
87 GDBusMethodInvocation *invocation,
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))
96 g_dbus_interface_skeleton_finalize (GObject *object)
98 GDBusInterfaceSkeleton *interface = G_DBUS_INTERFACE_SKELETON (object);
100 /* Hold the lock just incase any code we call verifies that the lock is held */
101 g_mutex_lock (&interface->priv->lock);
103 /* unexport from all connections if we're exported anywhere */
104 while (interface->priv->connections != NULL)
106 ConnectionData *data = interface->priv->connections->data;
107 remove_connection_locked (interface, data->connection);
110 set_object_path_locked (interface, NULL);
112 g_mutex_unlock (&interface->priv->lock);
114 g_free (interface->priv->hooked_vtable);
116 if (interface->priv->object != NULL)
117 g_object_remove_weak_pointer (G_OBJECT (interface->priv->object), (gpointer *) &interface->priv->object);
119 g_mutex_clear (&interface->priv->lock);
121 G_OBJECT_CLASS (g_dbus_interface_skeleton_parent_class)->finalize (object);
125 g_dbus_interface_skeleton_get_property (GObject *object,
130 GDBusInterfaceSkeleton *interface = G_DBUS_INTERFACE_SKELETON (object);
135 g_value_set_flags (value, g_dbus_interface_skeleton_get_flags (interface));
139 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
145 g_dbus_interface_skeleton_set_property (GObject *object,
150 GDBusInterfaceSkeleton *interface = G_DBUS_INTERFACE_SKELETON (object);
155 g_dbus_interface_skeleton_set_flags (interface, g_value_get_flags (value));
159 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
165 g_dbus_interface_skeleton_g_authorize_method_default (GDBusInterfaceSkeleton *interface,
166 GDBusMethodInvocation *invocation)
172 g_dbus_interface_skeleton_class_init (GDBusInterfaceSkeletonClass *klass)
174 GObjectClass *gobject_class;
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;
181 klass->g_authorize_method = g_dbus_interface_skeleton_g_authorize_method_default;
184 * GDBusInterfaceSkeleton:g-flags:
186 * Flags from the #GDBusInterfaceSkeletonFlags enumeration.
190 g_object_class_install_property (gobject_class,
192 g_param_spec_flags ("g-flags",
194 "Flags for the interface skeleton",
195 G_TYPE_DBUS_INTERFACE_SKELETON_FLAGS,
196 G_DBUS_INTERFACE_SKELETON_FLAGS_NONE,
199 G_PARAM_STATIC_STRINGS));
202 * GDBusInterfaceSkeleton::g-authorize-method:
203 * @interface: The #GDBusInterfaceSkeleton emitting the signal.
204 * @invocation: A #GDBusMethodInvocation.
206 * Emitted when a method is invoked by a remote caller and used to
207 * determine if the method call is authorized.
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)
214 * [POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION](http://hal.freedesktop.org/docs/polkit/PolkitAuthority.html#POLKIT-CHECK-AUTHORIZATION-FLAGS-ALLOW-USER-INTERACTION:CAPS)
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()).
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.
228 * The default class handler just returns %TRUE.
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
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.
240 * Returns: %TRUE if the call is authorized, %FALSE otherwise.
244 signals[G_AUTHORIZE_METHOD_SIGNAL] =
245 g_signal_new ("g-authorize-method",
246 G_TYPE_DBUS_INTERFACE_SKELETON,
248 G_STRUCT_OFFSET (GDBusInterfaceSkeletonClass, g_authorize_method),
249 _g_signal_accumulator_false_handled,
254 G_TYPE_DBUS_METHOD_INVOCATION);
258 g_dbus_interface_skeleton_init (GDBusInterfaceSkeleton *interface)
260 interface->priv = g_dbus_interface_skeleton_get_instance_private (interface);
261 g_mutex_init (&interface->priv->lock);
264 /* ---------------------------------------------------------------------------------------------------- */
267 * g_dbus_interface_skeleton_get_flags:
268 * @interface_: A #GDBusInterfaceSkeleton.
270 * Gets the #GDBusInterfaceSkeletonFlags that describes what the behavior
273 * Returns: One or more flags from the #GDBusInterfaceSkeletonFlags enumeration.
277 GDBusInterfaceSkeletonFlags
278 g_dbus_interface_skeleton_get_flags (GDBusInterfaceSkeleton *interface_)
280 g_return_val_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_), G_DBUS_INTERFACE_SKELETON_FLAGS_NONE);
281 return interface_->priv->flags;
285 * g_dbus_interface_skeleton_set_flags:
286 * @interface_: A #GDBusInterfaceSkeleton.
287 * @flags: Flags from the #GDBusInterfaceSkeletonFlags enumeration.
289 * Sets flags describing what the behavior of @skeleton should be.
294 g_dbus_interface_skeleton_set_flags (GDBusInterfaceSkeleton *interface_,
295 GDBusInterfaceSkeletonFlags flags)
297 g_return_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_));
298 g_mutex_lock (&interface_->priv->lock);
299 if (interface_->priv->flags != flags)
301 interface_->priv->flags = flags;
302 g_mutex_unlock (&interface_->priv->lock);
303 g_object_notify (G_OBJECT (interface_), "g-flags");
307 g_mutex_unlock (&interface_->priv->lock);
312 * g_dbus_interface_skeleton_get_info:
313 * @interface_: A #GDBusInterfaceSkeleton.
315 * Gets D-Bus introspection information for the D-Bus interface
316 * implemented by @interface_.
318 * Returns: (transfer none): A #GDBusInterfaceInfo (never %NULL). Do not free.
323 g_dbus_interface_skeleton_get_info (GDBusInterfaceSkeleton *interface_)
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);
333 * g_dbus_interface_skeleton_get_vtable: (skip)
334 * @interface_: A #GDBusInterfaceSkeleton.
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.
340 * Returns: A #GDBusInterfaceVTable (never %NULL).
344 GDBusInterfaceVTable *
345 g_dbus_interface_skeleton_get_vtable (GDBusInterfaceSkeleton *interface_)
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);
355 * g_dbus_interface_skeleton_get_properties:
356 * @interface_: A #GDBusInterfaceSkeleton.
358 * Gets all D-Bus properties for @interface_.
360 * Returns: (transfer full): A #GVariant of type <link linkend="G-VARIANT-TYPE-VARDICT:CAPS">'a{sv}'</link>. Free with g_variant_unref().
365 g_dbus_interface_skeleton_get_properties (GDBusInterfaceSkeleton *interface_)
368 g_return_val_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_), NULL);
369 ret = G_DBUS_INTERFACE_SKELETON_GET_CLASS (interface_)->get_properties (interface_);
370 return g_variant_take_ref (ret);
374 * g_dbus_interface_skeleton_flush:
375 * @interface_: A #GDBusInterfaceSkeleton.
377 * If @interface_ has outstanding changes, request for these changes to be
378 * emitted immediately.
380 * For example, an exported D-Bus interface may queue up property
381 * changes and emit the
382 * `org.freedesktop.DBus.Properties::Propert``
383 * signal later (e.g. in an idle handler). This technique is useful
384 * for collapsing multiple property changes into one.
389 g_dbus_interface_skeleton_flush (GDBusInterfaceSkeleton *interface_)
391 g_return_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_));
392 G_DBUS_INTERFACE_SKELETON_GET_CLASS (interface_)->flush (interface_);
395 /* ---------------------------------------------------------------------------------------------------- */
397 static GDBusInterfaceInfo *
398 _g_dbus_interface_skeleton_get_info (GDBusInterface *interface_)
400 GDBusInterfaceSkeleton *interface = G_DBUS_INTERFACE_SKELETON (interface_);
401 return g_dbus_interface_skeleton_get_info (interface);
405 g_dbus_interface_skeleton_get_object (GDBusInterface *interface_)
407 GDBusInterfaceSkeleton *interface = G_DBUS_INTERFACE_SKELETON (interface_);
409 g_mutex_lock (&interface->priv->lock);
410 ret = interface->priv->object;
411 g_mutex_unlock (&interface->priv->lock);
416 g_dbus_interface_skeleton_dup_object (GDBusInterface *interface_)
418 GDBusInterfaceSkeleton *interface = G_DBUS_INTERFACE_SKELETON (interface_);
420 g_mutex_lock (&interface->priv->lock);
421 ret = interface->priv->object;
424 g_mutex_unlock (&interface->priv->lock);
429 g_dbus_interface_skeleton_set_object (GDBusInterface *interface_,
432 GDBusInterfaceSkeleton *interface = G_DBUS_INTERFACE_SKELETON (interface_);
433 g_mutex_lock (&interface->priv->lock);
434 if (interface->priv->object != NULL)
435 g_object_remove_weak_pointer (G_OBJECT (interface->priv->object), (gpointer *) &interface->priv->object);
436 interface->priv->object = object;
438 g_object_add_weak_pointer (G_OBJECT (interface->priv->object), (gpointer *) &interface->priv->object);
439 g_mutex_unlock (&interface->priv->lock);
443 dbus_interface_interface_init (GDBusInterfaceIface *iface)
445 iface->get_info = _g_dbus_interface_skeleton_get_info;
446 iface->get_object = g_dbus_interface_skeleton_get_object;
447 iface->dup_object = g_dbus_interface_skeleton_dup_object;
448 iface->set_object = g_dbus_interface_skeleton_set_object;
451 /* ---------------------------------------------------------------------------------------------------- */
455 volatile gint ref_count;
456 GDBusInterfaceSkeleton *interface;
457 GDBusInterfaceMethodCallFunc method_call_func;
458 GDBusMethodInvocation *invocation;
462 dispatch_data_unref (DispatchData *data)
464 if (g_atomic_int_dec_and_test (&data->ref_count))
465 g_slice_free (DispatchData, data);
468 static DispatchData *
469 dispatch_data_ref (DispatchData *data)
471 g_atomic_int_inc (&data->ref_count);
476 dispatch_invoke_in_context_func (gpointer user_data)
478 DispatchData *data = user_data;
479 data->method_call_func (g_dbus_method_invocation_get_connection (data->invocation),
480 g_dbus_method_invocation_get_sender (data->invocation),
481 g_dbus_method_invocation_get_object_path (data->invocation),
482 g_dbus_method_invocation_get_interface_name (data->invocation),
483 g_dbus_method_invocation_get_method_name (data->invocation),
484 g_dbus_method_invocation_get_parameters (data->invocation),
486 g_dbus_method_invocation_get_user_data (data->invocation));
491 dispatch_in_thread_func (GTask *task,
492 gpointer source_object,
494 GCancellable *cancellable)
496 DispatchData *data = task_data;
497 GDBusInterfaceSkeletonFlags flags;
501 g_mutex_lock (&data->interface->priv->lock);
502 flags = data->interface->priv->flags;
503 object = data->interface->priv->object;
505 g_object_ref (object);
506 g_mutex_unlock (&data->interface->priv->lock);
508 /* first check on the enclosing object (if any), then the interface */
512 g_signal_emit_by_name (object,
520 g_signal_emit (data->interface,
521 signals[G_AUTHORIZE_METHOD_SIGNAL],
529 gboolean run_in_thread;
530 run_in_thread = (flags & G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD);
533 /* might as well just re-use the existing thread */
534 data->method_call_func (g_dbus_method_invocation_get_connection (data->invocation),
535 g_dbus_method_invocation_get_sender (data->invocation),
536 g_dbus_method_invocation_get_object_path (data->invocation),
537 g_dbus_method_invocation_get_interface_name (data->invocation),
538 g_dbus_method_invocation_get_method_name (data->invocation),
539 g_dbus_method_invocation_get_parameters (data->invocation),
541 g_dbus_method_invocation_get_user_data (data->invocation));
545 /* bah, back to original context */
546 g_main_context_invoke_full (g_task_get_context (task),
547 g_task_get_priority (task),
548 dispatch_invoke_in_context_func,
549 dispatch_data_ref (data),
550 (GDestroyNotify) dispatch_data_unref);
559 g_object_unref (object);
563 g_dbus_interface_method_dispatch_helper (GDBusInterfaceSkeleton *interface,
564 GDBusInterfaceMethodCallFunc method_call_func,
565 GDBusMethodInvocation *invocation)
567 gboolean has_handlers;
568 gboolean has_default_class_handler;
569 gboolean emit_authorized_signal;
570 gboolean run_in_thread;
571 GDBusInterfaceSkeletonFlags flags;
574 g_return_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface));
575 g_return_if_fail (method_call_func != NULL);
576 g_return_if_fail (G_IS_DBUS_METHOD_INVOCATION (invocation));
578 g_mutex_lock (&interface->priv->lock);
579 flags = interface->priv->flags;
580 object = interface->priv->object;
582 g_object_ref (object);
583 g_mutex_unlock (&interface->priv->lock);
585 /* optimization for the common case where
587 * a) no handler is connected and class handler is not overridden (both interface and object); and
588 * b) method calls are not dispatched in a thread
590 has_handlers = g_signal_has_handler_pending (interface,
591 signals[G_AUTHORIZE_METHOD_SIGNAL],
594 has_default_class_handler = (G_DBUS_INTERFACE_SKELETON_GET_CLASS (interface)->g_authorize_method ==
595 g_dbus_interface_skeleton_g_authorize_method_default);
597 emit_authorized_signal = (has_handlers || !has_default_class_handler);
598 if (!emit_authorized_signal)
601 emit_authorized_signal = _g_dbus_object_skeleton_has_authorize_method_handlers (G_DBUS_OBJECT_SKELETON (object));
604 run_in_thread = (flags & G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD);
605 if (!emit_authorized_signal && !run_in_thread)
607 method_call_func (g_dbus_method_invocation_get_connection (invocation),
608 g_dbus_method_invocation_get_sender (invocation),
609 g_dbus_method_invocation_get_object_path (invocation),
610 g_dbus_method_invocation_get_interface_name (invocation),
611 g_dbus_method_invocation_get_method_name (invocation),
612 g_dbus_method_invocation_get_parameters (invocation),
614 g_dbus_method_invocation_get_user_data (invocation));
621 data = g_slice_new0 (DispatchData);
622 data->interface = interface;
623 data->method_call_func = method_call_func;
624 data->invocation = invocation;
627 task = g_task_new (interface, NULL, NULL, NULL);
628 g_task_set_task_data (task, data, (GDestroyNotify) dispatch_data_unref);
629 g_task_run_in_thread (task, dispatch_in_thread_func);
630 g_object_unref (task);
634 g_object_unref (object);
638 skeleton_intercept_handle_method_call (GDBusConnection *connection,
640 const gchar *object_path,
641 const gchar *interface_name,
642 const gchar *method_name,
643 GVariant *parameters,
644 GDBusMethodInvocation *invocation,
647 GDBusInterfaceSkeleton *interface = G_DBUS_INTERFACE_SKELETON (user_data);
648 g_dbus_interface_method_dispatch_helper (interface,
649 g_dbus_interface_skeleton_get_vtable (interface)->method_call,
653 /* ---------------------------------------------------------------------------------------------------- */
655 static ConnectionData *
656 new_connection (GDBusConnection *connection,
657 guint registration_id)
659 ConnectionData *data;
661 data = g_slice_new0 (ConnectionData);
662 data->connection = g_object_ref (connection);
663 data->registration_id = registration_id;
669 free_connection (ConnectionData *data)
673 g_object_unref (data->connection);
674 g_slice_free (ConnectionData, data);
679 add_connection_locked (GDBusInterfaceSkeleton *interface_,
680 GDBusConnection *connection,
683 ConnectionData *data;
684 guint registration_id;
685 gboolean ret = FALSE;
687 if (interface_->priv->hooked_vtable == NULL)
689 /* Hook the vtable since we need to intercept method calls for
690 * ::g-authorize-method and for dispatching in thread vs
693 * We need to wait until subclasses have had time to initialize
694 * properly before building the hooked_vtable, so we create it
695 * once at the last minute.
697 interface_->priv->hooked_vtable = g_memdup (g_dbus_interface_skeleton_get_vtable (interface_), sizeof (GDBusInterfaceVTable));
698 interface_->priv->hooked_vtable->method_call = skeleton_intercept_handle_method_call;
701 registration_id = g_dbus_connection_register_object (connection,
702 interface_->priv->object_path,
703 g_dbus_interface_skeleton_get_info (interface_),
704 interface_->priv->hooked_vtable,
706 NULL, /* user_data_free_func */
709 if (registration_id > 0)
711 data = new_connection (connection, registration_id);
712 interface_->priv->connections = g_slist_append (interface_->priv->connections, data);
720 remove_connection_locked (GDBusInterfaceSkeleton *interface_,
721 GDBusConnection *connection)
723 ConnectionData *data;
726 /* Get the connection in the list and unregister ... */
727 for (l = interface_->priv->connections; l != NULL; l = l->next)
730 if (data->connection == connection)
732 g_warn_if_fail (g_dbus_connection_unregister_object (data->connection, data->registration_id));
733 free_connection (data);
734 interface_->priv->connections = g_slist_delete_link (interface_->priv->connections, l);
735 /* we are guaranteed that the connection is only added once, so bail out early */
744 set_object_path_locked (GDBusInterfaceSkeleton *interface_,
745 const gchar *object_path)
747 if (g_strcmp0 (interface_->priv->object_path, object_path) != 0)
749 g_free (interface_->priv->object_path);
750 interface_->priv->object_path = g_strdup (object_path);
754 /* ---------------------------------------------------------------------------------------------------- */
757 * g_dbus_interface_skeleton_get_connection:
758 * @interface_: A #GDBusInterfaceSkeleton.
760 * Gets the first connection that @interface_ is exported on, if any.
762 * Returns: (transfer none): A #GDBusConnection or %NULL if @interface_ is
763 * not exported anywhere. Do not free, the object belongs to @interface_.
768 g_dbus_interface_skeleton_get_connection (GDBusInterfaceSkeleton *interface_)
770 ConnectionData *data;
771 GDBusConnection *ret;
773 g_return_val_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_), NULL);
774 g_mutex_lock (&interface_->priv->lock);
777 if (interface_->priv->connections != NULL)
779 data = interface_->priv->connections->data;
781 ret = data->connection;
784 g_mutex_unlock (&interface_->priv->lock);
790 * g_dbus_interface_skeleton_get_connections:
791 * @interface_: A #GDBusInterfaceSkeleton.
793 * Gets a list of the connections that @interface_ is exported on.
795 * Returns: (element-type GDBusConnection) (transfer full): A list of
796 * all the connections that @interface_ is exported on. The returned
797 * list should be freed with g_list_free() after each element has
798 * been freed with g_object_unref().
803 g_dbus_interface_skeleton_get_connections (GDBusInterfaceSkeleton *interface_)
807 ConnectionData *data;
809 g_return_val_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_), NULL);
811 g_mutex_lock (&interface_->priv->lock);
814 for (l = interface_->priv->connections; l != NULL; l = l->next)
817 connections = g_list_prepend (connections,
818 /* Return a reference to each connection */
819 g_object_ref (data->connection));
822 g_mutex_unlock (&interface_->priv->lock);
824 return g_list_reverse (connections);
828 * g_dbus_interface_skeleton_has_connection:
829 * @interface_: A #GDBusInterfaceSkeleton.
830 * @connection: A #GDBusConnection.
832 * Checks if @interface_ is exported on @connection.
834 * Returns: %TRUE if @interface_ is exported on @connection, %FALSE otherwise.
839 g_dbus_interface_skeleton_has_connection (GDBusInterfaceSkeleton *interface_,
840 GDBusConnection *connection)
843 gboolean ret = FALSE;
845 g_return_val_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_), FALSE);
846 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), FALSE);
848 g_mutex_lock (&interface_->priv->lock);
850 for (l = interface_->priv->connections; l != NULL; l = l->next)
852 ConnectionData *data = l->data;
853 if (data->connection == connection)
861 g_mutex_unlock (&interface_->priv->lock);
866 * g_dbus_interface_skeleton_get_object_path:
867 * @interface_: A #GDBusInterfaceSkeleton.
869 * Gets the object path that @interface_ is exported on, if any.
871 * Returns: A string owned by @interface_ or %NULL if @interface_ is not exported
872 * anywhere. Do not free, the string belongs to @interface_.
877 g_dbus_interface_skeleton_get_object_path (GDBusInterfaceSkeleton *interface_)
880 g_return_val_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_), NULL);
881 g_mutex_lock (&interface_->priv->lock);
882 ret = interface_->priv->object_path;
883 g_mutex_unlock (&interface_->priv->lock);
888 * g_dbus_interface_skeleton_export:
889 * @interface_: The D-Bus interface to export.
890 * @connection: A #GDBusConnection to export @interface_ on.
891 * @object_path: The path to export the interface at.
892 * @error: Return location for error or %NULL.
894 * Exports @interface_ at @object_path on @connection.
896 * This can be called multiple times to export the same @interface_
897 * onto multiple connections however the @object_path provided must be
898 * the same for all connections.
900 * Use g_dbus_interface_skeleton_unexport() to unexport the object.
902 * Returns: %TRUE if the interface was exported on @connection, otherwise %FALSE with
908 g_dbus_interface_skeleton_export (GDBusInterfaceSkeleton *interface_,
909 GDBusConnection *connection,
910 const gchar *object_path,
913 gboolean ret = FALSE;
915 g_return_val_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_), FALSE);
916 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), FALSE);
917 g_return_val_if_fail (g_variant_is_object_path (object_path), FALSE);
918 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
920 /* Assert that the object path is the same for multiple connections here */
921 g_return_val_if_fail (interface_->priv->object_path == NULL ||
922 g_strcmp0 (interface_->priv->object_path, object_path) == 0, FALSE);
924 g_mutex_lock (&interface_->priv->lock);
926 /* Set the object path */
927 set_object_path_locked (interface_, object_path);
929 /* Add the connection */
930 ret = add_connection_locked (interface_, connection, error);
932 g_mutex_unlock (&interface_->priv->lock);
937 * g_dbus_interface_skeleton_unexport:
938 * @interface_: A #GDBusInterfaceSkeleton.
940 * Stops exporting @interface_ on all connections it is exported on.
942 * To unexport @interface_ from only a single connection, use
943 * g_dbus_interface_skeleton_unexport_from_connection()
948 g_dbus_interface_skeleton_unexport (GDBusInterfaceSkeleton *interface_)
950 g_return_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_));
951 g_return_if_fail (interface_->priv->connections != NULL);
953 g_mutex_lock (&interface_->priv->lock);
955 g_assert (interface_->priv->object_path != NULL);
956 g_assert (interface_->priv->hooked_vtable != NULL);
958 /* Remove all connections */
959 while (interface_->priv->connections != NULL)
961 ConnectionData *data = interface_->priv->connections->data;
962 remove_connection_locked (interface_, data->connection);
965 /* Unset the object path since there are no connections left */
966 set_object_path_locked (interface_, NULL);
968 g_mutex_unlock (&interface_->priv->lock);
973 * g_dbus_interface_skeleton_unexport_from_connection:
974 * @interface_: A #GDBusInterfaceSkeleton.
975 * @connection: A #GDBusConnection.
977 * Stops exporting @interface_ on @connection.
979 * To stop exporting on all connections the interface is exported on,
980 * use g_dbus_interface_skeleton_unexport().
985 g_dbus_interface_skeleton_unexport_from_connection (GDBusInterfaceSkeleton *interface_,
986 GDBusConnection *connection)
988 g_return_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_));
989 g_return_if_fail (G_IS_DBUS_CONNECTION (connection));
990 g_return_if_fail (interface_->priv->connections != NULL);
992 g_mutex_lock (&interface_->priv->lock);
994 g_assert (interface_->priv->object_path != NULL);
995 g_assert (interface_->priv->hooked_vtable != NULL);
997 remove_connection_locked (interface_, connection);
999 /* Reset the object path if we removed the last connection */
1000 if (interface_->priv->connections == NULL)
1001 set_object_path_locked (interface_, NULL);
1003 g_mutex_unlock (&interface_->priv->lock);
1006 /* ---------------------------------------------------------------------------------------------------- */