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 "gdbusobject.h"
24#include "gdbusobjectskeleton.h"
25#include "gdbusinterfaceskeleton.h"
26#include "gdbusprivate.h"
27#include "gdbusmethodinvocation.h"
28#include "gdbusintrospection.h"
29#include "gdbusinterface.h"
30#include "gdbusutils.h"
31
32#include "glibintl.h"
33
34/**
35 * SECTION:gdbusobjectskeleton
36 * @short_description: Service-side D-Bus object
37 * @include: gio/gio.h
38 *
39 * A #GDBusObjectSkeleton instance is essentially a group of D-Bus
40 * interfaces. The set of exported interfaces on the object may be
41 * dynamic and change at runtime.
42 *
43 * This type is intended to be used with #GDBusObjectManager.
44 */
45
46struct _GDBusObjectSkeletonPrivate
47{
48 GMutex lock;
49 gchar *object_path;
50 GHashTable *map_name_to_iface;
51};
52
53enum
54{
55 PROP_0,
56 PROP_G_OBJECT_PATH
57};
58
59enum
60{
61 AUTHORIZE_METHOD_SIGNAL,
62 LAST_SIGNAL,
63};
64
65static guint signals[LAST_SIGNAL] = {0};
66
67static void dbus_object_interface_init (GDBusObjectIface *iface);
68
69G_DEFINE_TYPE_WITH_CODE (GDBusObjectSkeleton, g_dbus_object_skeleton, G_TYPE_OBJECT,
70 G_ADD_PRIVATE (GDBusObjectSkeleton)
71 G_IMPLEMENT_INTERFACE (G_TYPE_DBUS_OBJECT, dbus_object_interface_init))
72
73
74static void
75g_dbus_object_skeleton_finalize (GObject *_object)
76{
77 GDBusObjectSkeleton *object = G_DBUS_OBJECT_SKELETON (_object);
78
79 g_free (mem: object->priv->object_path);
80 g_hash_table_unref (hash_table: object->priv->map_name_to_iface);
81
82 g_mutex_clear (mutex: &object->priv->lock);
83
84 if (G_OBJECT_CLASS (g_dbus_object_skeleton_parent_class)->finalize != NULL)
85 G_OBJECT_CLASS (g_dbus_object_skeleton_parent_class)->finalize (_object);
86}
87
88static void
89g_dbus_object_skeleton_get_property (GObject *_object,
90 guint prop_id,
91 GValue *value,
92 GParamSpec *pspec)
93{
94 GDBusObjectSkeleton *object = G_DBUS_OBJECT_SKELETON (_object);
95
96 switch (prop_id)
97 {
98 case PROP_G_OBJECT_PATH:
99 g_mutex_lock (mutex: &object->priv->lock);
100 g_value_set_string (value, v_string: object->priv->object_path);
101 g_mutex_unlock (mutex: &object->priv->lock);
102 break;
103
104 default:
105 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
106 break;
107 }
108}
109
110static void
111g_dbus_object_skeleton_set_property (GObject *_object,
112 guint prop_id,
113 const GValue *value,
114 GParamSpec *pspec)
115{
116 GDBusObjectSkeleton *object = G_DBUS_OBJECT_SKELETON (_object);
117
118 switch (prop_id)
119 {
120 case PROP_G_OBJECT_PATH:
121 g_dbus_object_skeleton_set_object_path (object, object_path: g_value_get_string (value));
122 break;
123
124 default:
125 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
126 break;
127 }
128}
129
130static gboolean
131g_dbus_object_skeleton_authorize_method_default (GDBusObjectSkeleton *object,
132 GDBusInterfaceSkeleton *interface,
133 GDBusMethodInvocation *invocation)
134{
135 return TRUE;
136}
137
138static void
139g_dbus_object_skeleton_class_init (GDBusObjectSkeletonClass *klass)
140{
141 GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
142
143 gobject_class->finalize = g_dbus_object_skeleton_finalize;
144 gobject_class->set_property = g_dbus_object_skeleton_set_property;
145 gobject_class->get_property = g_dbus_object_skeleton_get_property;
146
147 klass->authorize_method = g_dbus_object_skeleton_authorize_method_default;
148
149 /**
150 * GDBusObjectSkeleton:g-object-path:
151 *
152 * The object path where the object is exported.
153 *
154 * Since: 2.30
155 */
156 g_object_class_install_property (oclass: gobject_class,
157 property_id: PROP_G_OBJECT_PATH,
158 pspec: g_param_spec_string (name: "g-object-path",
159 nick: "Object Path",
160 blurb: "The object path where the object is exported",
161 NULL,
162 flags: G_PARAM_READABLE |
163 G_PARAM_WRITABLE |
164 G_PARAM_CONSTRUCT |
165 G_PARAM_STATIC_STRINGS));
166
167 /**
168 * GDBusObjectSkeleton::authorize-method:
169 * @object: The #GDBusObjectSkeleton emitting the signal.
170 * @interface: The #GDBusInterfaceSkeleton that @invocation is for.
171 * @invocation: A #GDBusMethodInvocation.
172 *
173 * Emitted when a method is invoked by a remote caller and used to
174 * determine if the method call is authorized.
175 *
176 * This signal is like #GDBusInterfaceSkeleton's
177 * #GDBusInterfaceSkeleton::g-authorize-method signal,
178 * except that it is for the enclosing object.
179 *
180 * The default class handler just returns %TRUE.
181 *
182 * Returns: %TRUE if the call is authorized, %FALSE otherwise.
183 *
184 * Since: 2.30
185 */
186 signals[AUTHORIZE_METHOD_SIGNAL] =
187 g_signal_new (I_("authorize-method"),
188 G_TYPE_DBUS_OBJECT_SKELETON,
189 signal_flags: G_SIGNAL_RUN_LAST,
190 G_STRUCT_OFFSET (GDBusObjectSkeletonClass, authorize_method),
191 accumulator: _g_signal_accumulator_false_handled,
192 NULL,
193 NULL,
194 G_TYPE_BOOLEAN,
195 n_params: 2,
196 G_TYPE_DBUS_INTERFACE_SKELETON,
197 G_TYPE_DBUS_METHOD_INVOCATION);
198}
199
200static void
201g_dbus_object_skeleton_init (GDBusObjectSkeleton *object)
202{
203 object->priv = g_dbus_object_skeleton_get_instance_private (self: object);
204 g_mutex_init (mutex: &object->priv->lock);
205 object->priv->map_name_to_iface = g_hash_table_new_full (hash_func: g_str_hash,
206 key_equal_func: g_str_equal,
207 key_destroy_func: g_free,
208 value_destroy_func: (GDestroyNotify) g_object_unref);
209}
210
211/**
212 * g_dbus_object_skeleton_new:
213 * @object_path: An object path.
214 *
215 * Creates a new #GDBusObjectSkeleton.
216 *
217 * Returns: A #GDBusObjectSkeleton. Free with g_object_unref().
218 *
219 * Since: 2.30
220 */
221GDBusObjectSkeleton *
222g_dbus_object_skeleton_new (const gchar *object_path)
223{
224 g_return_val_if_fail (g_variant_is_object_path (object_path), NULL);
225 return G_DBUS_OBJECT_SKELETON (g_object_new (G_TYPE_DBUS_OBJECT_SKELETON,
226 "g-object-path", object_path,
227 NULL));
228}
229
230/**
231 * g_dbus_object_skeleton_set_object_path:
232 * @object: A #GDBusObjectSkeleton.
233 * @object_path: A valid D-Bus object path.
234 *
235 * Sets the object path for @object.
236 *
237 * Since: 2.30
238 */
239void
240g_dbus_object_skeleton_set_object_path (GDBusObjectSkeleton *object,
241 const gchar *object_path)
242{
243 g_return_if_fail (G_IS_DBUS_OBJECT_SKELETON (object));
244 g_return_if_fail (object_path == NULL || g_variant_is_object_path (object_path));
245 g_mutex_lock (mutex: &object->priv->lock);
246 /* TODO: fail if object is currently exported */
247 if (g_strcmp0 (str1: object->priv->object_path, str2: object_path) != 0)
248 {
249 g_free (mem: object->priv->object_path);
250 object->priv->object_path = g_strdup (str: object_path);
251 g_mutex_unlock (mutex: &object->priv->lock);
252 g_object_notify (G_OBJECT (object), property_name: "g-object-path");
253 }
254 else
255 {
256 g_mutex_unlock (mutex: &object->priv->lock);
257 }
258}
259
260static const gchar *
261g_dbus_object_skeleton_get_object_path (GDBusObject *_object)
262{
263 GDBusObjectSkeleton *object = G_DBUS_OBJECT_SKELETON (_object);
264 const gchar *ret;
265 g_mutex_lock (mutex: &object->priv->lock);
266 ret = object->priv->object_path;
267 g_mutex_unlock (mutex: &object->priv->lock);
268 return ret;
269}
270
271/**
272 * g_dbus_object_skeleton_add_interface:
273 * @object: A #GDBusObjectSkeleton.
274 * @interface_: A #GDBusInterfaceSkeleton.
275 *
276 * Adds @interface_ to @object.
277 *
278 * If @object already contains a #GDBusInterfaceSkeleton with the same
279 * interface name, it is removed before @interface_ is added.
280 *
281 * Note that @object takes its own reference on @interface_ and holds
282 * it until removed.
283 *
284 * Since: 2.30
285 */
286void
287g_dbus_object_skeleton_add_interface (GDBusObjectSkeleton *object,
288 GDBusInterfaceSkeleton *interface_)
289{
290 GDBusInterfaceInfo *info;
291 GDBusInterface *interface_to_remove;
292
293 g_return_if_fail (G_IS_DBUS_OBJECT_SKELETON (object));
294 g_return_if_fail (G_IS_DBUS_INTERFACE_SKELETON (interface_));
295
296 g_mutex_lock (mutex: &object->priv->lock);
297
298 info = g_dbus_interface_skeleton_get_info (interface_);
299 g_object_ref (interface_);
300
301 interface_to_remove = g_hash_table_lookup (hash_table: object->priv->map_name_to_iface, key: info->name);
302 if (interface_to_remove != NULL)
303 {
304 g_object_ref (interface_to_remove);
305 g_warn_if_fail (g_hash_table_remove (object->priv->map_name_to_iface, info->name));
306 }
307 g_hash_table_insert (hash_table: object->priv->map_name_to_iface,
308 key: g_strdup (str: info->name),
309 g_object_ref (interface_));
310 g_dbus_interface_set_object (G_DBUS_INTERFACE (interface_), G_DBUS_OBJECT (object));
311
312 g_mutex_unlock (mutex: &object->priv->lock);
313
314 if (interface_to_remove != NULL)
315 {
316 g_dbus_interface_set_object (interface_: interface_to_remove, NULL);
317 g_signal_emit_by_name (instance: object,
318 detailed_signal: "interface-removed",
319 interface_to_remove);
320 g_object_unref (object: interface_to_remove);
321 }
322
323 g_signal_emit_by_name (instance: object,
324 detailed_signal: "interface-added",
325 interface_);
326 g_object_unref (object: interface_);
327}
328
329/**
330 * g_dbus_object_skeleton_remove_interface:
331 * @object: A #GDBusObjectSkeleton.
332 * @interface_: A #GDBusInterfaceSkeleton.
333 *
334 * Removes @interface_ from @object.
335 *
336 * Since: 2.30
337 */
338void
339g_dbus_object_skeleton_remove_interface (GDBusObjectSkeleton *object,
340 GDBusInterfaceSkeleton *interface_)
341{
342 GDBusInterfaceSkeleton *other_interface;
343 GDBusInterfaceInfo *info;
344
345 g_return_if_fail (G_IS_DBUS_OBJECT_SKELETON (object));
346 g_return_if_fail (G_IS_DBUS_INTERFACE (interface_));
347
348 g_mutex_lock (mutex: &object->priv->lock);
349
350 info = g_dbus_interface_skeleton_get_info (interface_);
351
352 other_interface = g_hash_table_lookup (hash_table: object->priv->map_name_to_iface, key: info->name);
353 if (other_interface == NULL)
354 {
355 g_mutex_unlock (mutex: &object->priv->lock);
356 g_warning ("Tried to remove interface with name %s from object "
357 "at path %s but no such interface exists",
358 info->name,
359 object->priv->object_path);
360 }
361 else if (other_interface != interface_)
362 {
363 g_mutex_unlock (mutex: &object->priv->lock);
364 g_warning ("Tried to remove interface %p with name %s from object "
365 "at path %s but the object has the interface %p",
366 interface_,
367 info->name,
368 object->priv->object_path,
369 other_interface);
370 }
371 else
372 {
373 g_object_ref (interface_);
374 g_warn_if_fail (g_hash_table_remove (object->priv->map_name_to_iface, info->name));
375 g_mutex_unlock (mutex: &object->priv->lock);
376 g_dbus_interface_set_object (G_DBUS_INTERFACE (interface_), NULL);
377 g_signal_emit_by_name (instance: object,
378 detailed_signal: "interface-removed",
379 interface_);
380 g_object_unref (object: interface_);
381 }
382}
383
384
385/**
386 * g_dbus_object_skeleton_remove_interface_by_name:
387 * @object: A #GDBusObjectSkeleton.
388 * @interface_name: A D-Bus interface name.
389 *
390 * Removes the #GDBusInterface with @interface_name from @object.
391 *
392 * If no D-Bus interface of the given interface exists, this function
393 * does nothing.
394 *
395 * Since: 2.30
396 */
397void
398g_dbus_object_skeleton_remove_interface_by_name (GDBusObjectSkeleton *object,
399 const gchar *interface_name)
400{
401 GDBusInterface *interface;
402
403 g_return_if_fail (G_IS_DBUS_OBJECT_SKELETON (object));
404 g_return_if_fail (g_dbus_is_interface_name (interface_name));
405
406 g_mutex_lock (mutex: &object->priv->lock);
407 interface = g_hash_table_lookup (hash_table: object->priv->map_name_to_iface, key: interface_name);
408 if (interface != NULL)
409 {
410 g_object_ref (interface);
411 g_warn_if_fail (g_hash_table_remove (object->priv->map_name_to_iface, interface_name));
412 g_mutex_unlock (mutex: &object->priv->lock);
413 g_dbus_interface_set_object (interface_: interface, NULL);
414 g_signal_emit_by_name (instance: object,
415 detailed_signal: "interface-removed",
416 interface);
417 g_object_unref (object: interface);
418 }
419 else
420 {
421 g_mutex_unlock (mutex: &object->priv->lock);
422 }
423}
424
425static GDBusInterface *
426g_dbus_object_skeleton_get_interface (GDBusObject *_object,
427 const gchar *interface_name)
428{
429 GDBusObjectSkeleton *object = G_DBUS_OBJECT_SKELETON (_object);
430 GDBusInterface *ret;
431
432 g_return_val_if_fail (G_IS_DBUS_OBJECT_SKELETON (object), NULL);
433 g_return_val_if_fail (g_dbus_is_interface_name (interface_name), NULL);
434
435 g_mutex_lock (mutex: &object->priv->lock);
436 ret = g_hash_table_lookup (hash_table: object->priv->map_name_to_iface, key: interface_name);
437 if (ret != NULL)
438 g_object_ref (ret);
439 g_mutex_unlock (mutex: &object->priv->lock);
440 return ret;
441}
442
443static GList *
444g_dbus_object_skeleton_get_interfaces (GDBusObject *_object)
445{
446 GDBusObjectSkeleton *object = G_DBUS_OBJECT_SKELETON (_object);
447 GList *ret;
448
449 g_return_val_if_fail (G_IS_DBUS_OBJECT_SKELETON (object), NULL);
450
451 ret = NULL;
452
453 g_mutex_lock (mutex: &object->priv->lock);
454 ret = g_hash_table_get_values (hash_table: object->priv->map_name_to_iface);
455 g_list_foreach (list: ret, func: (GFunc) g_object_ref, NULL);
456 g_mutex_unlock (mutex: &object->priv->lock);
457
458 return ret;
459}
460
461/**
462 * g_dbus_object_skeleton_flush:
463 * @object: A #GDBusObjectSkeleton.
464 *
465 * This method simply calls g_dbus_interface_skeleton_flush() on all
466 * interfaces belonging to @object. See that method for when flushing
467 * is useful.
468 *
469 * Since: 2.30
470 */
471void
472g_dbus_object_skeleton_flush (GDBusObjectSkeleton *object)
473{
474 GList *to_flush, *l;
475
476 g_mutex_lock (mutex: &object->priv->lock);
477 to_flush = g_hash_table_get_values (hash_table: object->priv->map_name_to_iface);
478 g_list_foreach (list: to_flush, func: (GFunc) g_object_ref, NULL);
479 g_mutex_unlock (mutex: &object->priv->lock);
480
481 for (l = to_flush; l != NULL; l = l->next)
482 g_dbus_interface_skeleton_flush (G_DBUS_INTERFACE_SKELETON (l->data));
483
484 g_list_free_full (list: to_flush, free_func: g_object_unref);
485}
486
487static void
488dbus_object_interface_init (GDBusObjectIface *iface)
489{
490 iface->get_object_path = g_dbus_object_skeleton_get_object_path;
491 iface->get_interfaces = g_dbus_object_skeleton_get_interfaces;
492 iface->get_interface = g_dbus_object_skeleton_get_interface;
493}
494
495gboolean
496_g_dbus_object_skeleton_has_authorize_method_handlers (GDBusObjectSkeleton *object)
497{
498 gboolean has_handlers;
499 gboolean has_default_class_handler;
500
501 has_handlers = g_signal_has_handler_pending (instance: object,
502 signal_id: signals[AUTHORIZE_METHOD_SIGNAL],
503 detail: 0,
504 TRUE);
505 has_default_class_handler = (G_DBUS_OBJECT_SKELETON_GET_CLASS (object)->authorize_method ==
506 g_dbus_object_skeleton_authorize_method_default);
507
508 return has_handlers || !has_default_class_handler;
509}
510

source code of gtk/subprojects/glib/gio/gdbusobjectskeleton.c