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 | |
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 (mutex: &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_: interface, connection: data->connection); |
109 | } |
110 | |
111 | set_object_path_locked (interface_: interface, NULL); |
112 | |
113 | g_mutex_unlock (mutex: &interface->priv->lock); |
114 | |
115 | g_free (mem: interface->priv->hooked_vtable); |
116 | |
117 | if (interface->priv->object != NULL) |
118 | g_object_remove_weak_pointer (G_OBJECT (interface->priv->object), weak_pointer_location: (gpointer *) &interface->priv->object); |
119 | |
120 | g_mutex_clear (mutex: &interface->priv->lock); |
121 | |
122 | G_OBJECT_CLASS (g_dbus_interface_skeleton_parent_class)->finalize (object); |
123 | } |
124 | |
125 | static void |
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, v_flags: g_dbus_interface_skeleton_get_flags (interface_: 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 |
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_: interface, flags: 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 |
166 | g_dbus_interface_skeleton_g_authorize_method_default (GDBusInterfaceSkeleton *interface, |
167 | GDBusMethodInvocation *invocation) |
168 | { |
169 | return TRUE; |
170 | } |
171 | |
172 | static void |
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 (oclass: gobject_class, |
192 | property_id: PROP_G_FLAGS, |
193 | pspec: g_param_spec_flags (name: "g-flags" , |
194 | nick: "g-flags" , |
195 | blurb: "Flags for the interface skeleton" , |
196 | flags_type: G_TYPE_DBUS_INTERFACE_SKELETON_FLAGS, |
197 | default_value: G_DBUS_INTERFACE_SKELETON_FLAGS_NONE, |
198 | flags: 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 | signal_flags: G_SIGNAL_RUN_LAST, |
249 | G_STRUCT_OFFSET (GDBusInterfaceSkeletonClass, g_authorize_method), |
250 | accumulator: _g_signal_accumulator_false_handled, |
251 | NULL, |
252 | c_marshaller: _g_cclosure_marshal_BOOLEAN__OBJECT, |
253 | G_TYPE_BOOLEAN, |
254 | n_params: 1, |
255 | G_TYPE_DBUS_METHOD_INVOCATION); |
256 | g_signal_set_va_marshaller (signal_id: signals[G_AUTHORIZE_METHOD_SIGNAL], |
257 | G_TYPE_FROM_CLASS (klass), |
258 | va_marshaller: _g_cclosure_marshal_BOOLEAN__OBJECTv); |
259 | } |
260 | |
261 | static void |
262 | g_dbus_interface_skeleton_init (GDBusInterfaceSkeleton *interface) |
263 | { |
264 | interface->priv = g_dbus_interface_skeleton_get_instance_private (self: interface); |
265 | g_mutex_init (mutex: &interface->priv->lock); |
266 | } |
267 | |
268 | /* ---------------------------------------------------------------------------------------------------- */ |
269 | |
270 | /** |
271 | * g_dbus_interface_skeleton_get_flags: |
272 | * @interface_: A #GDBusInterfaceSkeleton. |
273 | * |
274 | * Gets the #GDBusInterfaceSkeletonFlags that describes what the behavior |
275 | * of @interface_ |
276 | * |
277 | * Returns: One or more flags from the #GDBusInterfaceSkeletonFlags enumeration. |
278 | * |
279 | * Since: 2.30 |
280 | */ |
281 | GDBusInterfaceSkeletonFlags |
282 | g_dbus_interface_skeleton_get_flags (GDBusInterfaceSkeleton *interface_) |
283 | { |
284 | g_return_val_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_), G_DBUS_INTERFACE_SKELETON_FLAGS_NONE); |
285 | return interface_->priv->flags; |
286 | } |
287 | |
288 | /** |
289 | * g_dbus_interface_skeleton_set_flags: |
290 | * @interface_: A #GDBusInterfaceSkeleton. |
291 | * @flags: Flags from the #GDBusInterfaceSkeletonFlags enumeration. |
292 | * |
293 | * Sets flags describing what the behavior of @skeleton should be. |
294 | * |
295 | * Since: 2.30 |
296 | */ |
297 | void |
298 | g_dbus_interface_skeleton_set_flags (GDBusInterfaceSkeleton *interface_, |
299 | GDBusInterfaceSkeletonFlags flags) |
300 | { |
301 | g_return_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_)); |
302 | g_mutex_lock (mutex: &interface_->priv->lock); |
303 | if (interface_->priv->flags != flags) |
304 | { |
305 | interface_->priv->flags = flags; |
306 | g_mutex_unlock (mutex: &interface_->priv->lock); |
307 | g_object_notify (G_OBJECT (interface_), property_name: "g-flags" ); |
308 | } |
309 | else |
310 | { |
311 | g_mutex_unlock (mutex: &interface_->priv->lock); |
312 | } |
313 | } |
314 | |
315 | /** |
316 | * g_dbus_interface_skeleton_get_info: |
317 | * @interface_: A #GDBusInterfaceSkeleton. |
318 | * |
319 | * Gets D-Bus introspection information for the D-Bus interface |
320 | * implemented by @interface_. |
321 | * |
322 | * Returns: (transfer none): A #GDBusInterfaceInfo (never %NULL). Do not free. |
323 | * |
324 | * Since: 2.30 |
325 | */ |
326 | GDBusInterfaceInfo * |
327 | g_dbus_interface_skeleton_get_info (GDBusInterfaceSkeleton *interface_) |
328 | { |
329 | GDBusInterfaceInfo *ret; |
330 | g_return_val_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_), NULL); |
331 | ret = G_DBUS_INTERFACE_SKELETON_GET_CLASS (interface_)->get_info (interface_); |
332 | g_warn_if_fail (ret != NULL); |
333 | return ret; |
334 | } |
335 | |
336 | /** |
337 | * g_dbus_interface_skeleton_get_vtable: (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 * |
349 | g_dbus_interface_skeleton_get_vtable (GDBusInterfaceSkeleton *interface_) |
350 | { |
351 | GDBusInterfaceVTable *ret; |
352 | g_return_val_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_), NULL); |
353 | ret = G_DBUS_INTERFACE_SKELETON_GET_CLASS (interface_)->get_vtable (interface_); |
354 | g_warn_if_fail (ret != NULL); |
355 | return ret; |
356 | } |
357 | |
358 | /** |
359 | * g_dbus_interface_skeleton_get_properties: |
360 | * @interface_: A #GDBusInterfaceSkeleton. |
361 | * |
362 | * Gets all D-Bus properties for @interface_. |
363 | * |
364 | * Returns: (transfer full): A #GVariant of type |
365 | * ['a{sv}'][G-VARIANT-TYPE-VARDICT:CAPS]. |
366 | * Free with g_variant_unref(). |
367 | * |
368 | * Since: 2.30 |
369 | */ |
370 | GVariant * |
371 | g_dbus_interface_skeleton_get_properties (GDBusInterfaceSkeleton *interface_) |
372 | { |
373 | GVariant *ret; |
374 | g_return_val_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_), NULL); |
375 | ret = G_DBUS_INTERFACE_SKELETON_GET_CLASS (interface_)->get_properties (interface_); |
376 | return g_variant_take_ref (value: ret); |
377 | } |
378 | |
379 | /** |
380 | * g_dbus_interface_skeleton_flush: |
381 | * @interface_: A #GDBusInterfaceSkeleton. |
382 | * |
383 | * If @interface_ has outstanding changes, request for these changes to be |
384 | * emitted immediately. |
385 | * |
386 | * For example, an exported D-Bus interface may queue up property |
387 | * changes and emit the |
388 | * `org.freedesktop.DBus.Properties.PropertiesChanged` |
389 | * signal later (e.g. in an idle handler). This technique is useful |
390 | * for collapsing multiple property changes into one. |
391 | * |
392 | * Since: 2.30 |
393 | */ |
394 | void |
395 | g_dbus_interface_skeleton_flush (GDBusInterfaceSkeleton *interface_) |
396 | { |
397 | g_return_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_)); |
398 | G_DBUS_INTERFACE_SKELETON_GET_CLASS (interface_)->flush (interface_); |
399 | } |
400 | |
401 | /* ---------------------------------------------------------------------------------------------------- */ |
402 | |
403 | static GDBusInterfaceInfo * |
404 | _g_dbus_interface_skeleton_get_info (GDBusInterface *interface_) |
405 | { |
406 | GDBusInterfaceSkeleton *interface = G_DBUS_INTERFACE_SKELETON (interface_); |
407 | return g_dbus_interface_skeleton_get_info (interface_: interface); |
408 | } |
409 | |
410 | static GDBusObject * |
411 | g_dbus_interface_skeleton_get_object (GDBusInterface *interface_) |
412 | { |
413 | GDBusInterfaceSkeleton *interface = G_DBUS_INTERFACE_SKELETON (interface_); |
414 | GDBusObject *ret; |
415 | g_mutex_lock (mutex: &interface->priv->lock); |
416 | ret = interface->priv->object; |
417 | g_mutex_unlock (mutex: &interface->priv->lock); |
418 | return ret; |
419 | } |
420 | |
421 | static GDBusObject * |
422 | g_dbus_interface_skeleton_dup_object (GDBusInterface *interface_) |
423 | { |
424 | GDBusInterfaceSkeleton *interface = G_DBUS_INTERFACE_SKELETON (interface_); |
425 | GDBusObject *ret; |
426 | g_mutex_lock (mutex: &interface->priv->lock); |
427 | ret = interface->priv->object; |
428 | if (ret != NULL) |
429 | g_object_ref (ret); |
430 | g_mutex_unlock (mutex: &interface->priv->lock); |
431 | return ret; |
432 | } |
433 | |
434 | static void |
435 | g_dbus_interface_skeleton_set_object (GDBusInterface *interface_, |
436 | GDBusObject *object) |
437 | { |
438 | GDBusInterfaceSkeleton *interface = G_DBUS_INTERFACE_SKELETON (interface_); |
439 | g_mutex_lock (mutex: &interface->priv->lock); |
440 | if (interface->priv->object != NULL) |
441 | g_object_remove_weak_pointer (G_OBJECT (interface->priv->object), weak_pointer_location: (gpointer *) &interface->priv->object); |
442 | interface->priv->object = object; |
443 | if (object != NULL) |
444 | g_object_add_weak_pointer (G_OBJECT (interface->priv->object), weak_pointer_location: (gpointer *) &interface->priv->object); |
445 | g_mutex_unlock (mutex: &interface->priv->lock); |
446 | } |
447 | |
448 | static void |
449 | dbus_interface_interface_init (GDBusInterfaceIface *iface) |
450 | { |
451 | iface->get_info = _g_dbus_interface_skeleton_get_info; |
452 | iface->get_object = g_dbus_interface_skeleton_get_object; |
453 | iface->dup_object = g_dbus_interface_skeleton_dup_object; |
454 | iface->set_object = g_dbus_interface_skeleton_set_object; |
455 | } |
456 | |
457 | /* ---------------------------------------------------------------------------------------------------- */ |
458 | |
459 | typedef struct |
460 | { |
461 | gint ref_count; /* (atomic) */ |
462 | GDBusInterfaceSkeleton *interface; |
463 | GDBusInterfaceMethodCallFunc method_call_func; |
464 | GDBusMethodInvocation *invocation; |
465 | } DispatchData; |
466 | |
467 | static void |
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 * |
475 | dispatch_data_ref (DispatchData *data) |
476 | { |
477 | g_atomic_int_inc (&data->ref_count); |
478 | return data; |
479 | } |
480 | |
481 | static gboolean |
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 (invocation: data->invocation), |
486 | g_dbus_method_invocation_get_sender (invocation: data->invocation), |
487 | g_dbus_method_invocation_get_object_path (invocation: data->invocation), |
488 | g_dbus_method_invocation_get_interface_name (invocation: data->invocation), |
489 | g_dbus_method_invocation_get_method_name (invocation: data->invocation), |
490 | g_dbus_method_invocation_get_parameters (invocation: data->invocation), |
491 | data->invocation, |
492 | g_dbus_method_invocation_get_user_data (invocation: data->invocation)); |
493 | return FALSE; |
494 | } |
495 | |
496 | static void |
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 (mutex: &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 (mutex: &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 (instance: object, |
519 | detailed_signal: "authorize-method" , |
520 | data->interface, |
521 | data->invocation, |
522 | &authorized); |
523 | } |
524 | if (authorized) |
525 | { |
526 | g_signal_emit (instance: data->interface, |
527 | signal_id: signals[G_AUTHORIZE_METHOD_SIGNAL], |
528 | detail: 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 (invocation: data->invocation), |
541 | g_dbus_method_invocation_get_sender (invocation: data->invocation), |
542 | g_dbus_method_invocation_get_object_path (invocation: data->invocation), |
543 | g_dbus_method_invocation_get_interface_name (invocation: data->invocation), |
544 | g_dbus_method_invocation_get_method_name (invocation: data->invocation), |
545 | g_dbus_method_invocation_get_parameters (invocation: data->invocation), |
546 | data->invocation, |
547 | g_dbus_method_invocation_get_user_data (invocation: data->invocation)); |
548 | } |
549 | else |
550 | { |
551 | /* bah, back to original context */ |
552 | g_main_context_invoke_full (context: g_task_get_context (task), |
553 | priority: g_task_get_priority (task), |
554 | function: dispatch_invoke_in_context_func, |
555 | data: dispatch_data_ref (data), |
556 | notify: (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 |
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 (mutex: &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 (mutex: &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 (instance: interface, |
597 | signal_id: signals[G_AUTHORIZE_METHOD_SIGNAL], |
598 | detail: 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 (source_object: interface, NULL, NULL, NULL); |
634 | g_task_set_source_tag (task, g_dbus_interface_method_dispatch_helper); |
635 | g_task_set_name (task, name: "[gio] D-Bus interface method dispatch" ); |
636 | g_task_set_task_data (task, task_data: data, task_data_destroy: (GDestroyNotify) dispatch_data_unref); |
637 | g_task_run_in_thread (task, task_func: dispatch_in_thread_func); |
638 | g_object_unref (object: task); |
639 | } |
640 | |
641 | if (object != NULL) |
642 | g_object_unref (object); |
643 | } |
644 | |
645 | static void |
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 | method_call_func: g_dbus_interface_skeleton_get_vtable (interface_: interface)->method_call, |
658 | invocation); |
659 | } |
660 | |
661 | /* ---------------------------------------------------------------------------------------------------- */ |
662 | |
663 | static ConnectionData * |
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 |
677 | free_connection (ConnectionData *data) |
678 | { |
679 | if (data != NULL) |
680 | { |
681 | g_object_unref (object: data->connection); |
682 | g_slice_free (ConnectionData, data); |
683 | } |
684 | } |
685 | |
686 | static gboolean |
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 (mem: g_dbus_interface_skeleton_get_vtable (interface_), byte_size: 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 | object_path: interface_->priv->object_path, |
711 | interface_info: g_dbus_interface_skeleton_get_info (interface_), |
712 | vtable: interface_->priv->hooked_vtable, |
713 | user_data: 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 (list: interface_->priv->connections, data); |
721 | ret = TRUE; |
722 | } |
723 | |
724 | return ret; |
725 | } |
726 | |
727 | static void |
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 (list: interface_->priv->connections, link_: 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 |
752 | set_object_path_locked (GDBusInterfaceSkeleton *interface_, |
753 | const gchar *object_path) |
754 | { |
755 | if (g_strcmp0 (str1: interface_->priv->object_path, str2: object_path) != 0) |
756 | { |
757 | g_free (mem: interface_->priv->object_path); |
758 | interface_->priv->object_path = g_strdup (str: 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 * |
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 (mutex: &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 (mutex: &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 * |
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 (mutex: &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 (list: connections, |
826 | /* Return a reference to each connection */ |
827 | g_object_ref (data->connection)); |
828 | } |
829 | |
830 | g_mutex_unlock (mutex: &interface_->priv->lock); |
831 | |
832 | return g_list_reverse (list: 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 |
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 (mutex: &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 (mutex: &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 * |
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 (mutex: &interface_->priv->lock); |
890 | ret = interface_->priv->object_path; |
891 | g_mutex_unlock (mutex: &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 |
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 (mutex: &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 (mutex: &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 |
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 (mutex: &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_, connection: 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 (mutex: &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 |
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 (mutex: &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 (mutex: &interface_->priv->lock); |
1012 | } |
1013 | |
1014 | /* ---------------------------------------------------------------------------------------------------- */ |
1015 | |