nexmon – Blame information for rev 1

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