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