1 /* GDBus - GLib D-Bus Library
3 * Copyright (C) 2008-2010 Red Hat, Inc.
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General
16 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 * Author: David Zeuthen <davidz@redhat.com>
24 * - would be nice to expose GDBusAuthMechanism and an extension point
26 * - Need to rewrite GDBusAuth and rework GDBusAuthMechanism. In particular
27 * the mechanism VFuncs need to be able to set an error.
29 * - Need to document other mechanisms/sources for determining the D-Bus
30 * address of a well-known bus.
32 * - e.g. on Win32 we need code like from here
34 * http://cgit.freedesktop.org/~david/gdbus-standalone/tree/gdbus/gdbusaddress.c#n900
36 * that was never copied over here because it originally was copy-paste
37 * from the GPLv2 / AFL 2.1 libdbus sources.
39 * - on OS X we need to look in launchd for the address
41 * https://bugs.freedesktop.org/show_bug.cgi?id=14259
43 * - on X11 we need to look in a X11 property on the X server
44 * - (we can also just use dbus-launch(1) from the D-Bus
47 * - (ideally) this requires D-Bus spec work because none of
48 * this has never really been specced out properly (except
51 * - Related to the above, we also need to be able to launch a message bus
52 * instance.... Since we don't want to write our own bus daemon we should
53 * launch dbus-daemon(1) (thus: Win32 and OS X need to bundle it)
55 * - probably want a G_DBUS_NONCE_TCP_TMPDIR environment variable
56 * to specify where the nonce is stored. This will allow people to use
57 * G_DBUS_NONCE_TCP_TMPDIR=/mnt/secure.company.server/dbus-nonce-dir
58 * to easily achieve secure RPC via nonce-tcp.
60 * - need to expose an extension point for resolving D-Bus address and
61 * turning them into GIOStream objects. This will allow us to implement
62 * e.g. X11 D-Bus transports without dlopen()'ing or linking against
64 * - see g_dbus_address_connect() in gdbusaddress.c
66 * - would be cute to use kernel-specific APIs to resolve fds for
67 * debug output when using G_DBUS_DEBUG=message, e.g. in addition to
69 * fd 21: dev=8:1,mode=0100644,ino=1171231,uid=0,gid=0,rdev=0:0,size=234,atime=1273070640,mtime=1267126160,ctime=1267126160
71 * maybe we can show more information about what fd 21 really is.
72 * Ryan suggests looking in /proc/self/fd for clues / symlinks!
73 * Initial experiments on Linux 2.6 suggests that the symlink looks
78 * e.g. not of much use.
80 * - GDBus High-Level docs
81 * - Proxy: properties, signals...
82 * - Connection: IOStream based, ::close, connection setup steps
83 * mainloop integration, threading
84 * - Differences from libdbus (extend "Migrating from")
85 * - the message handling thread
86 * - Using GVariant instead of GValue
87 * - Explain why the high-level API is a good thing and what
88 * kind of pitfalls it avoids
89 * - Export objects before claiming names
90 * - Talk about auto-starting services (cf. GBusNameWatcherFlags)
92 * - use abstract sockets in test code
93 * - right now it doesn't work, dbus-daemon(1) fails with
95 * /gdbus/connection/filter: Failed to start message bus: Failed to bind
96 * socket "/tmp/g-dbus-tests-pid-28531": Address already in use
97 * ** WARNING **: Error reading address from dbus daemon, 0 bytes read
107 #include "gdbusauth.h"
108 #include "gdbusutils.h"
109 #include "gdbusaddress.h"
110 #include "gdbusmessage.h"
111 #include "gdbusconnection.h"
112 #include "gdbuserror.h"
113 #include "gioenumtypes.h"
114 #include "gdbusintrospection.h"
115 #include "gdbusmethodinvocation.h"
116 #include "gdbusprivate.h"
117 #include "gdbusauthobserver.h"
118 #include "ginitable.h"
119 #include "gasyncinitable.h"
120 #include "giostream.h"
121 #include "gasyncresult.h"
125 #include "gunixconnection.h"
126 #include "gunixfdmessage.h"
129 #include "glibintl.h"
132 * SECTION:gdbusconnection
133 * @short_description: D-Bus Connections
134 * @include: gio/gio.h
136 * The #GDBusConnection type is used for D-Bus connections to remote
137 * peers such as a message buses. It is a low-level API that offers a
138 * lot of flexibility. For instance, it lets you establish a connection
139 * over any transport that can by represented as an #GIOStream.
141 * This class is rarely used directly in D-Bus clients. If you are writing
142 * a D-Bus client, it is often easier to use the g_bus_own_name(),
143 * g_bus_watch_name() or g_dbus_proxy_new_for_bus() APIs.
145 * As an exception to the usual GLib rule that a particular object must not
146 * be used by two threads at the same time, #GDBusConnection's methods may be
147 * called from any thread. This is so that g_bus_get() and g_bus_get_sync()
148 * can safely return the same #GDBusConnection when called from any thread.
150 * Most of the ways to obtain a #GDBusConnection automatically initialize it
151 * (i.e. connect to D-Bus): for instance, g_dbus_connection_new() and
152 * g_bus_get(), and the synchronous versions of those methods, give you an
153 * initialized connection. Language bindings for GIO should use
154 * g_initable_new() or g_async_initable_new_async(), which also initialize the
157 * If you construct an uninitialized #GDBusConnection, such as via
158 * g_object_new(), you must initialize it via g_initable_init() or
159 * g_async_initable_init_async() before using its methods or properties.
160 * Calling methods or accessing properties on a #GDBusConnection that has not
161 * completed initialization successfully is considered to be invalid, and leads
162 * to undefined behaviour. In particular, if initialization fails with a
163 * #GError, the only valid thing you can do with that #GDBusConnection is to
164 * free it with g_object_unref().
166 * ## An example D-Bus server # {#gdbus-server}
168 * Here is an example for a D-Bus server:
169 * [gdbus-example-server.c](https://git.gnome.org/browse/glib/tree/gio/tests/gdbus-example-server.c)
171 * ## An example for exporting a subtree # {#gdbus-subtree-server}
173 * Here is an example for exporting a subtree:
174 * [gdbus-example-subtree.c](https://git.gnome.org/browse/glib/tree/gio/tests/gdbus-example-subtree.c)
176 * ## An example for file descriptor passing # {#gdbus-unix-fd-client}
178 * Here is an example for passing UNIX file descriptors:
179 * [gdbus-unix-fd-client.c](https://git.gnome.org/browse/glib/tree/gio/tests/gdbus-unix-fd-client.c)
181 * ## An example for exporting a GObject # {#gdbus-export}
183 * Here is an example for exporting a #GObject:
184 * [gdbus-example-export.c](https://git.gnome.org/browse/glib/tree/gio/tests/gdbus-example-export.c)
187 /* ---------------------------------------------------------------------------------------------------- */
189 typedef struct _GDBusConnectionClass GDBusConnectionClass
;
192 * GDBusConnectionClass:
193 * @closed: Signal class handler for the #GDBusConnection::closed signal.
195 * Class structure for #GDBusConnection.
199 struct _GDBusConnectionClass
202 GObjectClass parent_class
;
206 void (*closed
) (GDBusConnection
*connection
,
207 gboolean remote_peer_vanished
,
211 G_LOCK_DEFINE_STATIC (message_bus_lock
);
213 static GWeakRef the_session_bus
;
214 static GWeakRef the_system_bus
;
216 /* Extra pseudo-member of GDBusSendMessageFlags.
217 * Set by initable_init() to indicate that despite not being initialized yet,
218 * enough of the only-valid-after-init members are set that we can send a
219 * message, and we're being called from its thread, so no memory barrier is
220 * required before accessing them.
222 #define SEND_MESSAGE_FLAGS_INITIALIZING (1u << 31)
224 /* Same as SEND_MESSAGE_FLAGS_INITIALIZING, but in GDBusCallFlags */
225 #define CALL_FLAGS_INITIALIZING (1u << 31)
227 /* ---------------------------------------------------------------------------------------------------- */
231 GDestroyNotify callback
;
233 GMainContext
*context
;
234 } CallDestroyNotifyData
;
237 call_destroy_notify_data_in_idle (gpointer user_data
)
239 CallDestroyNotifyData
*data
= user_data
;
240 data
->callback (data
->user_data
);
245 call_destroy_notify_data_free (CallDestroyNotifyData
*data
)
247 if (data
->context
!= NULL
)
248 g_main_context_unref (data
->context
);
253 * call_destroy_notify: <internal>
254 * @context: (nullable): A #GMainContext or %NULL.
255 * @callback: (nullable): A #GDestroyNotify or %NULL.
256 * @user_data: Data to pass to @callback.
258 * Schedules @callback to run in @context.
261 call_destroy_notify (GMainContext
*context
,
262 GDestroyNotify callback
,
265 GSource
*idle_source
;
266 CallDestroyNotifyData
*data
;
268 if (callback
== NULL
)
271 data
= g_new0 (CallDestroyNotifyData
, 1);
272 data
->callback
= callback
;
273 data
->user_data
= user_data
;
274 data
->context
= context
;
275 if (data
->context
!= NULL
)
276 g_main_context_ref (data
->context
);
278 idle_source
= g_idle_source_new ();
279 g_source_set_priority (idle_source
, G_PRIORITY_DEFAULT
);
280 g_source_set_callback (idle_source
,
281 call_destroy_notify_data_in_idle
,
283 (GDestroyNotify
) call_destroy_notify_data_free
);
284 g_source_set_name (idle_source
, "[gio] call_destroy_notify_data_in_idle");
285 g_source_attach (idle_source
, data
->context
);
286 g_source_unref (idle_source
);
292 /* ---------------------------------------------------------------------------------------------------- */
295 _g_strv_has_string (const gchar
* const *haystack
,
300 for (n
= 0; haystack
!= NULL
&& haystack
[n
] != NULL
; n
++)
302 if (g_strcmp0 (haystack
[n
], needle
) == 0)
308 /* ---------------------------------------------------------------------------------------------------- */
311 #define CONNECTION_ENSURE_LOCK(obj) do { ; } while (FALSE)
313 // TODO: for some reason this doesn't work on Windows
314 #define CONNECTION_ENSURE_LOCK(obj) do { \
315 if (G_UNLIKELY (g_mutex_trylock(&(obj)->lock))) \
317 g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
318 "CONNECTION_ENSURE_LOCK: GDBusConnection object lock is not locked"); \
323 #define CONNECTION_LOCK(obj) do { \
324 g_mutex_lock (&(obj)->lock); \
327 #define CONNECTION_UNLOCK(obj) do { \
328 g_mutex_unlock (&(obj)->lock); \
331 /* Flags in connection->atomic_flags */
333 FLAG_INITIALIZED
= 1 << 0,
334 FLAG_EXIT_ON_CLOSE
= 1 << 1,
341 * The #GDBusConnection structure contains only private data and
342 * should only be accessed using the provided API.
346 struct _GDBusConnection
349 GObject parent_instance
;
351 /* ------------------------------------------------------------------------ */
352 /* -- General object state ------------------------------------------------ */
353 /* ------------------------------------------------------------------------ */
355 /* General-purpose lock for most fields */
358 /* A lock used in the init() method of the GInitable interface - see comments
359 * in initable_init() for why a separate lock is needed.
361 * If you need both @lock and @init_lock, you must take @init_lock first.
365 /* Set (by loading the contents of /var/lib/dbus/machine-id) the first time
366 * someone calls org.freedesktop.DBus.Peer.GetMachineId(). Protected by @lock.
370 /* The underlying stream used for communication
371 * Read-only after initable_init(), so it may be read if you either
372 * hold @init_lock or check for initialization first.
376 /* The object used for authentication (if any).
377 * Read-only after initable_init(), so it may be read if you either
378 * hold @init_lock or check for initialization first.
382 /* Last serial used. Protected by @lock. */
385 /* The object used to send/receive messages.
386 * Read-only after initable_init(), so it may be read if you either
387 * hold @init_lock or check for initialization first.
391 /* If connected to a message bus, this contains the unique name assigned to
392 * us by the bus (e.g. ":1.42").
393 * Read-only after initable_init(), so it may be read if you either
394 * hold @init_lock or check for initialization first.
396 gchar
*bus_unique_name
;
398 /* The GUID returned by the other side if we authenticed as a client or
399 * the GUID to use if authenticating as a server.
400 * Read-only after initable_init(), so it may be read if you either
401 * hold @init_lock or check for initialization first.
405 /* FLAG_INITIALIZED is set exactly when initable_init() has finished running.
406 * Inspect @initialization_error to see whether it succeeded or failed.
408 * FLAG_EXIT_ON_CLOSE is the exit-on-close property.
410 * FLAG_CLOSED is the closed property. It may be read at any time, but
411 * may only be written while holding @lock.
413 volatile gint atomic_flags
;
415 /* If the connection could not be established during initable_init(),
416 * this GError will be set.
417 * Read-only after initable_init(), so it may be read if you either
418 * hold @init_lock or check for initialization first.
420 GError
*initialization_error
;
422 /* The result of g_main_context_ref_thread_default() when the object
423 * was created (the GObject _init() function) - this is used for delivery
424 * of the :closed GObject signal.
426 * Only set in the GObject init function, so no locks are needed.
428 GMainContext
*main_context_at_construction
;
430 /* Read-only construct properties, no locks needed */
432 GDBusConnectionFlags flags
;
434 /* Map used for managing method replies, protected by @lock */
435 GHashTable
*map_method_serial_to_task
; /* guint32 -> GTask* */
437 /* Maps used for managing signal subscription, protected by @lock */
438 GHashTable
*map_rule_to_signal_data
; /* match rule (gchar*) -> SignalData */
439 GHashTable
*map_id_to_signal_data
; /* id (guint) -> SignalData */
440 GHashTable
*map_sender_unique_name_to_signal_data_array
; /* unique sender (gchar*) -> GPtrArray* of SignalData */
442 /* Maps used for managing exported objects and subtrees,
445 GHashTable
*map_object_path_to_eo
; /* gchar* -> ExportedObject* */
446 GHashTable
*map_id_to_ei
; /* guint -> ExportedInterface* */
447 GHashTable
*map_object_path_to_es
; /* gchar* -> ExportedSubtree* */
448 GHashTable
*map_id_to_es
; /* guint -> ExportedSubtree* */
450 /* Map used for storing last used serials for each thread, protected by @lock */
451 GHashTable
*map_thread_to_last_serial
;
453 /* Structure used for message filters, protected by @lock */
456 /* Capabilities negotiated during authentication
457 * Read-only after initable_init(), so it may be read without holding a
458 * lock, if you check for initialization first.
460 GDBusCapabilityFlags capabilities
;
462 /* Protected by @init_lock */
463 GDBusAuthObserver
*authentication_observer
;
465 /* Read-only after initable_init(), so it may be read if you either
466 * hold @init_lock or check for initialization first.
468 GCredentials
*credentials
;
470 /* set to TRUE when finalizing */
474 typedef struct ExportedObject ExportedObject
;
475 static void exported_object_free (ExportedObject
*eo
);
477 typedef struct ExportedSubtree ExportedSubtree
;
478 static void exported_subtree_free (ExportedSubtree
*es
);
496 PROP_CAPABILITY_FLAGS
,
497 PROP_AUTHENTICATION_OBSERVER
,
500 static void distribute_signals (GDBusConnection
*connection
,
501 GDBusMessage
*message
);
503 static void distribute_method_call (GDBusConnection
*connection
,
504 GDBusMessage
*message
);
506 static gboolean
handle_generic_unlocked (GDBusConnection
*connection
,
507 GDBusMessage
*message
);
510 static void purge_all_signal_subscriptions (GDBusConnection
*connection
);
511 static void purge_all_filters (GDBusConnection
*connection
);
513 static void schedule_method_call (GDBusConnection
*connection
,
514 GDBusMessage
*message
,
515 guint registration_id
,
516 guint subtree_registration_id
,
517 const GDBusInterfaceInfo
*interface_info
,
518 const GDBusMethodInfo
*method_info
,
519 const GDBusPropertyInfo
*property_info
,
520 GVariant
*parameters
,
521 const GDBusInterfaceVTable
*vtable
,
522 GMainContext
*main_context
,
525 #define _G_ENSURE_LOCK(name) do { \
526 if (G_UNLIKELY (G_TRYLOCK(name))) \
528 g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
529 "_G_ENSURE_LOCK: Lock '" #name "' is not locked"); \
533 static guint signals[LAST_SIGNAL] = { 0 };
535 static void initable_iface_init (GInitableIface
*initable_iface
);
536 static void async_initable_iface_init (GAsyncInitableIface
*async_initable_iface
);
538 G_DEFINE_TYPE_WITH_CODE (GDBusConnection
, g_dbus_connection
, G_TYPE_OBJECT
,
539 G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE
, initable_iface_init
)
540 G_IMPLEMENT_INTERFACE (G_TYPE_ASYNC_INITABLE
, async_initable_iface_init
)
544 * Check that all members of @connection that can only be accessed after
545 * the connection is initialized can safely be accessed. If not,
546 * log a critical warning. This function is a memory barrier.
548 * Returns: %TRUE if initialized
551 check_initialized (GDBusConnection
*connection
)
553 /* The access to @atomic_flags isn't conditional, so that this function
554 * provides a memory barrier for thread-safety even if checks are disabled.
555 * (If you don't want this stricter guarantee, you can call
556 * g_return_if_fail (check_initialized (c)).)
558 * This isn't strictly necessary now that we've decided use of an
559 * uninitialized GDBusConnection is undefined behaviour, but it seems
560 * better to be as deterministic as is feasible.
562 * (Anything that could suffer a crash from seeing undefined values
563 * must have a race condition - thread A initializes the connection while
564 * thread B calls a method without initialization, hoping that thread A will
565 * win the race - so its behaviour is undefined anyway.)
567 gint flags
= g_atomic_int_get (&connection
->atomic_flags
);
569 g_return_val_if_fail (flags
& FLAG_INITIALIZED
, FALSE
);
571 /* We can safely access this, due to the memory barrier above */
572 g_return_val_if_fail (connection
->initialization_error
== NULL
, FALSE
);
578 MAY_BE_UNINITIALIZED
= (1<<1)
579 } CheckUnclosedFlags
;
582 * Check the same thing as check_initialized(), and also that the
583 * connection is not closed. If the connection is uninitialized,
584 * raise a critical warning (it's programmer error); if it's closed,
585 * raise a recoverable GError (it's a runtime error).
587 * This function is a memory barrier.
589 * Returns: %TRUE if initialized and not closed
592 check_unclosed (GDBusConnection
*connection
,
593 CheckUnclosedFlags check
,
596 /* check_initialized() is effectively inlined, so we don't waste time
597 * doing two memory barriers
599 gint flags
= g_atomic_int_get (&connection
->atomic_flags
);
601 if (!(check
& MAY_BE_UNINITIALIZED
))
603 g_return_val_if_fail (flags
& FLAG_INITIALIZED
, FALSE
);
604 g_return_val_if_fail (connection
->initialization_error
== NULL
, FALSE
);
607 if (flags
& FLAG_CLOSED
)
609 g_set_error_literal (error
,
612 _("The connection is closed"));
619 static GHashTable
*alive_connections
= NULL
;
622 g_dbus_connection_dispose (GObject
*object
)
624 GDBusConnection
*connection
= G_DBUS_CONNECTION (object
);
626 G_LOCK (message_bus_lock
);
627 CONNECTION_LOCK (connection
);
628 if (connection
->worker
!= NULL
)
630 _g_dbus_worker_stop (connection
->worker
);
631 connection
->worker
= NULL
;
632 if (alive_connections
!= NULL
)
633 g_warn_if_fail (g_hash_table_remove (alive_connections
, connection
));
637 if (alive_connections
!= NULL
)
638 g_warn_if_fail (g_hash_table_lookup (alive_connections
, connection
) == NULL
);
640 CONNECTION_UNLOCK (connection
);
641 G_UNLOCK (message_bus_lock
);
643 if (G_OBJECT_CLASS (g_dbus_connection_parent_class
)->dispose
!= NULL
)
644 G_OBJECT_CLASS (g_dbus_connection_parent_class
)->dispose (object
);
648 g_dbus_connection_finalize (GObject
*object
)
650 GDBusConnection
*connection
= G_DBUS_CONNECTION (object
);
652 connection
->finalizing
= TRUE
;
654 purge_all_signal_subscriptions (connection
);
656 purge_all_filters (connection
);
657 g_ptr_array_unref (connection
->filters
);
659 if (connection
->authentication_observer
!= NULL
)
660 g_object_unref (connection
->authentication_observer
);
662 if (connection
->auth
!= NULL
)
663 g_object_unref (connection
->auth
);
665 if (connection
->credentials
)
666 g_object_unref (connection
->credentials
);
668 if (connection
->stream
!= NULL
)
670 g_object_unref (connection
->stream
);
671 connection
->stream
= NULL
;
674 g_free (connection
->address
);
676 g_free (connection
->guid
);
677 g_free (connection
->bus_unique_name
);
679 if (connection
->initialization_error
!= NULL
)
680 g_error_free (connection
->initialization_error
);
682 g_hash_table_unref (connection
->map_method_serial_to_task
);
684 g_hash_table_unref (connection
->map_rule_to_signal_data
);
685 g_hash_table_unref (connection
->map_id_to_signal_data
);
686 g_hash_table_unref (connection
->map_sender_unique_name_to_signal_data_array
);
688 g_hash_table_unref (connection
->map_id_to_ei
);
689 g_hash_table_unref (connection
->map_object_path_to_eo
);
690 g_hash_table_unref (connection
->map_id_to_es
);
691 g_hash_table_unref (connection
->map_object_path_to_es
);
693 g_hash_table_unref (connection
->map_thread_to_last_serial
);
695 g_main_context_unref (connection
->main_context_at_construction
);
697 g_free (connection
->machine_id
);
699 g_mutex_clear (&connection
->init_lock
);
700 g_mutex_clear (&connection
->lock
);
702 G_OBJECT_CLASS (g_dbus_connection_parent_class
)->finalize (object
);
705 /* called in any user thread, with the connection's lock not held */
707 g_dbus_connection_get_property (GObject
*object
,
712 GDBusConnection
*connection
= G_DBUS_CONNECTION (object
);
717 g_value_set_object (value
, g_dbus_connection_get_stream (connection
));
721 g_value_set_string (value
, g_dbus_connection_get_guid (connection
));
724 case PROP_UNIQUE_NAME
:
725 g_value_set_string (value
, g_dbus_connection_get_unique_name (connection
));
729 g_value_set_boolean (value
, g_dbus_connection_is_closed (connection
));
732 case PROP_EXIT_ON_CLOSE
:
733 g_value_set_boolean (value
, g_dbus_connection_get_exit_on_close (connection
));
736 case PROP_CAPABILITY_FLAGS
:
737 g_value_set_flags (value
, g_dbus_connection_get_capabilities (connection
));
741 G_OBJECT_WARN_INVALID_PROPERTY_ID (object
, prop_id
, pspec
);
746 /* called in any user thread, with the connection's lock not held */
748 g_dbus_connection_set_property (GObject
*object
,
753 GDBusConnection
*connection
= G_DBUS_CONNECTION (object
);
758 connection
->stream
= g_value_dup_object (value
);
762 connection
->guid
= g_value_dup_string (value
);
766 connection
->address
= g_value_dup_string (value
);
770 connection
->flags
= g_value_get_flags (value
);
773 case PROP_EXIT_ON_CLOSE
:
774 g_dbus_connection_set_exit_on_close (connection
, g_value_get_boolean (value
));
777 case PROP_AUTHENTICATION_OBSERVER
:
778 connection
->authentication_observer
= g_value_dup_object (value
);
782 G_OBJECT_WARN_INVALID_PROPERTY_ID (object
, prop_id
, pspec
);
787 /* Base-class implementation of GDBusConnection::closed.
789 * Called in a user thread, by the main context that was thread-default when
790 * the object was constructed.
793 g_dbus_connection_real_closed (GDBusConnection
*connection
,
794 gboolean remote_peer_vanished
,
797 gint flags
= g_atomic_int_get (&connection
->atomic_flags
);
799 /* Because atomic int access is a memory barrier, we can safely read
800 * initialization_error without a lock, as long as we do it afterwards.
802 if (remote_peer_vanished
&&
803 (flags
& FLAG_EXIT_ON_CLOSE
) != 0 &&
804 (flags
& FLAG_INITIALIZED
) != 0 &&
805 connection
->initialization_error
== NULL
)
812 g_dbus_connection_class_init (GDBusConnectionClass
*klass
)
814 GObjectClass
*gobject_class
;
816 gobject_class
= G_OBJECT_CLASS (klass
);
818 gobject_class
->finalize
= g_dbus_connection_finalize
;
819 gobject_class
->dispose
= g_dbus_connection_dispose
;
820 gobject_class
->set_property
= g_dbus_connection_set_property
;
821 gobject_class
->get_property
= g_dbus_connection_get_property
;
823 klass
->closed
= g_dbus_connection_real_closed
;
826 * GDBusConnection:stream:
828 * The underlying #GIOStream used for I/O.
830 * If this is passed on construction and is a #GSocketConnection,
831 * then the corresponding #GSocket will be put into non-blocking mode.
833 * While the #GDBusConnection is active, it will interact with this
834 * stream from a worker thread, so it is not safe to interact with
835 * the stream directly.
839 g_object_class_install_property (gobject_class
,
841 g_param_spec_object ("stream",
843 P_("The underlying streams used for I/O"),
847 G_PARAM_CONSTRUCT_ONLY
|
848 G_PARAM_STATIC_NAME
|
849 G_PARAM_STATIC_BLURB
|
850 G_PARAM_STATIC_NICK
));
853 * GDBusConnection:address:
855 * A D-Bus address specifying potential endpoints that can be used
856 * when establishing the connection.
860 g_object_class_install_property (gobject_class
,
862 g_param_spec_string ("address",
864 P_("D-Bus address specifying potential socket endpoints"),
867 G_PARAM_CONSTRUCT_ONLY
|
868 G_PARAM_STATIC_NAME
|
869 G_PARAM_STATIC_BLURB
|
870 G_PARAM_STATIC_NICK
));
873 * GDBusConnection:flags:
875 * Flags from the #GDBusConnectionFlags enumeration.
879 g_object_class_install_property (gobject_class
,
881 g_param_spec_flags ("flags",
884 G_TYPE_DBUS_CONNECTION_FLAGS
,
885 G_DBUS_CONNECTION_FLAGS_NONE
,
887 G_PARAM_CONSTRUCT_ONLY
|
888 G_PARAM_STATIC_NAME
|
889 G_PARAM_STATIC_BLURB
|
890 G_PARAM_STATIC_NICK
));
893 * GDBusConnection:guid:
895 * The GUID of the peer performing the role of server when
898 * If you are constructing a #GDBusConnection and pass
899 * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER in the
900 * #GDBusConnection:flags property then you MUST also set this
901 * property to a valid guid.
903 * If you are constructing a #GDBusConnection and pass
904 * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT in the
905 * #GDBusConnection:flags property you will be able to read the GUID
906 * of the other peer here after the connection has been successfully
911 g_object_class_install_property (gobject_class
,
913 g_param_spec_string ("guid",
915 P_("GUID of the server peer"),
919 G_PARAM_CONSTRUCT_ONLY
|
920 G_PARAM_STATIC_NAME
|
921 G_PARAM_STATIC_BLURB
|
922 G_PARAM_STATIC_NICK
));
925 * GDBusConnection:unique-name:
927 * The unique name as assigned by the message bus or %NULL if the
928 * connection is not open or not a message bus connection.
932 g_object_class_install_property (gobject_class
,
934 g_param_spec_string ("unique-name",
936 P_("Unique name of bus connection"),
939 G_PARAM_STATIC_NAME
|
940 G_PARAM_STATIC_BLURB
|
941 G_PARAM_STATIC_NICK
));
944 * GDBusConnection:closed:
946 * A boolean specifying whether the connection has been closed.
950 g_object_class_install_property (gobject_class
,
952 g_param_spec_boolean ("closed",
954 P_("Whether the connection is closed"),
957 G_PARAM_STATIC_NAME
|
958 G_PARAM_STATIC_BLURB
|
959 G_PARAM_STATIC_NICK
));
962 * GDBusConnection:exit-on-close:
964 * A boolean specifying whether the process will be terminated (by
965 * calling `raise(SIGTERM)`) if the connection is closed by the
968 * Note that #GDBusConnection objects returned by g_bus_get_finish()
969 * and g_bus_get_sync() will (usually) have this property set to %TRUE.
973 g_object_class_install_property (gobject_class
,
975 g_param_spec_boolean ("exit-on-close",
977 P_("Whether the process is terminated when the connection is closed"),
981 G_PARAM_STATIC_NAME
|
982 G_PARAM_STATIC_BLURB
|
983 G_PARAM_STATIC_NICK
));
986 * GDBusConnection:capabilities:
988 * Flags from the #GDBusCapabilityFlags enumeration
989 * representing connection features negotiated with the other peer.
993 g_object_class_install_property (gobject_class
,
994 PROP_CAPABILITY_FLAGS
,
995 g_param_spec_flags ("capabilities",
998 G_TYPE_DBUS_CAPABILITY_FLAGS
,
999 G_DBUS_CAPABILITY_FLAGS_NONE
,
1001 G_PARAM_STATIC_NAME
|
1002 G_PARAM_STATIC_BLURB
|
1003 G_PARAM_STATIC_NICK
));
1006 * GDBusConnection:authentication-observer:
1008 * A #GDBusAuthObserver object to assist in the authentication process or %NULL.
1012 g_object_class_install_property (gobject_class
,
1013 PROP_AUTHENTICATION_OBSERVER
,
1014 g_param_spec_object ("authentication-observer",
1015 P_("Authentication Observer"),
1016 P_("Object used to assist in the authentication process"),
1017 G_TYPE_DBUS_AUTH_OBSERVER
,
1019 G_PARAM_CONSTRUCT_ONLY
|
1020 G_PARAM_STATIC_NAME
|
1021 G_PARAM_STATIC_BLURB
|
1022 G_PARAM_STATIC_NICK
));
1025 * GDBusConnection::closed:
1026 * @connection: the #GDBusConnection emitting the signal
1027 * @remote_peer_vanished: %TRUE if @connection is closed because the
1028 * remote peer closed its end of the connection
1029 * @error: (nullable): a #GError with more details about the event or %NULL
1031 * Emitted when the connection is closed.
1033 * The cause of this event can be
1035 * - If g_dbus_connection_close() is called. In this case
1036 * @remote_peer_vanished is set to %FALSE and @error is %NULL.
1038 * - If the remote peer closes the connection. In this case
1039 * @remote_peer_vanished is set to %TRUE and @error is set.
1041 * - If the remote peer sends invalid or malformed data. In this
1042 * case @remote_peer_vanished is set to %FALSE and @error is set.
1044 * Upon receiving this signal, you should give up your reference to
1045 * @connection. You are guaranteed that this signal is emitted only
1050 signals
[CLOSED_SIGNAL
] = g_signal_new (I_("closed"),
1051 G_TYPE_DBUS_CONNECTION
,
1053 G_STRUCT_OFFSET (GDBusConnectionClass
, closed
),
1064 g_dbus_connection_init (GDBusConnection
*connection
)
1066 g_mutex_init (&connection
->lock
);
1067 g_mutex_init (&connection
->init_lock
);
1069 connection
->map_method_serial_to_task
= g_hash_table_new (g_direct_hash
, g_direct_equal
);
1071 connection
->map_rule_to_signal_data
= g_hash_table_new (g_str_hash
,
1073 connection
->map_id_to_signal_data
= g_hash_table_new (g_direct_hash
,
1075 connection
->map_sender_unique_name_to_signal_data_array
= g_hash_table_new_full (g_str_hash
,
1078 (GDestroyNotify
) g_ptr_array_unref
);
1080 connection
->map_object_path_to_eo
= g_hash_table_new_full (g_str_hash
,
1083 (GDestroyNotify
) exported_object_free
);
1085 connection
->map_id_to_ei
= g_hash_table_new (g_direct_hash
,
1088 connection
->map_object_path_to_es
= g_hash_table_new_full (g_str_hash
,
1091 (GDestroyNotify
) exported_subtree_free
);
1093 connection
->map_id_to_es
= g_hash_table_new (g_direct_hash
,
1096 connection
->map_thread_to_last_serial
= g_hash_table_new (g_direct_hash
,
1099 connection
->main_context_at_construction
= g_main_context_ref_thread_default ();
1101 connection
->filters
= g_ptr_array_new ();
1105 * g_dbus_connection_get_stream:
1106 * @connection: a #GDBusConnection
1108 * Gets the underlying stream used for IO.
1110 * While the #GDBusConnection is active, it will interact with this
1111 * stream from a worker thread, so it is not safe to interact with
1112 * the stream directly.
1114 * Returns: (transfer none): the stream used for IO
1119 g_dbus_connection_get_stream (GDBusConnection
*connection
)
1121 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), NULL
);
1123 /* do not use g_return_val_if_fail(), we want the memory barrier */
1124 if (!check_initialized (connection
))
1127 return connection
->stream
;
1131 * g_dbus_connection_start_message_processing:
1132 * @connection: a #GDBusConnection
1134 * If @connection was created with
1135 * %G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING, this method
1136 * starts processing messages. Does nothing on if @connection wasn't
1137 * created with this flag or if the method has already been called.
1142 g_dbus_connection_start_message_processing (GDBusConnection
*connection
)
1144 g_return_if_fail (G_IS_DBUS_CONNECTION (connection
));
1146 /* do not use g_return_val_if_fail(), we want the memory barrier */
1147 if (!check_initialized (connection
))
1150 g_assert (connection
->worker
!= NULL
);
1151 _g_dbus_worker_unfreeze (connection
->worker
);
1155 * g_dbus_connection_is_closed:
1156 * @connection: a #GDBusConnection
1158 * Gets whether @connection is closed.
1160 * Returns: %TRUE if the connection is closed, %FALSE otherwise
1165 g_dbus_connection_is_closed (GDBusConnection
*connection
)
1169 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), FALSE
);
1171 flags
= g_atomic_int_get (&connection
->atomic_flags
);
1173 return (flags
& FLAG_CLOSED
) ? TRUE
: FALSE
;
1177 * g_dbus_connection_get_capabilities:
1178 * @connection: a #GDBusConnection
1180 * Gets the capabilities negotiated with the remote peer
1182 * Returns: zero or more flags from the #GDBusCapabilityFlags enumeration
1186 GDBusCapabilityFlags
1187 g_dbus_connection_get_capabilities (GDBusConnection
*connection
)
1189 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), G_DBUS_CAPABILITY_FLAGS_NONE
);
1191 /* do not use g_return_val_if_fail(), we want the memory barrier */
1192 if (!check_initialized (connection
))
1193 return G_DBUS_CAPABILITY_FLAGS_NONE
;
1195 return connection
->capabilities
;
1198 /* ---------------------------------------------------------------------------------------------------- */
1200 /* Called in a temporary thread without holding locks. */
1202 flush_in_thread_func (GTask
*task
,
1203 gpointer source_object
,
1205 GCancellable
*cancellable
)
1207 GError
*error
= NULL
;
1209 if (g_dbus_connection_flush_sync (source_object
,
1212 g_task_return_boolean (task
, TRUE
);
1214 g_task_return_error (task
, error
);
1218 * g_dbus_connection_flush:
1219 * @connection: a #GDBusConnection
1220 * @cancellable: (nullable): a #GCancellable or %NULL
1221 * @callback: (nullable): a #GAsyncReadyCallback to call when the
1222 * request is satisfied or %NULL if you don't care about the result
1223 * @user_data: The data to pass to @callback
1225 * Asynchronously flushes @connection, that is, writes all queued
1226 * outgoing message to the transport and then flushes the transport
1227 * (using g_output_stream_flush_async()). This is useful in programs
1228 * that wants to emit a D-Bus signal and then exit immediately. Without
1229 * flushing the connection, there is no guaranteed that the message has
1230 * been sent to the networking buffers in the OS kernel.
1232 * This is an asynchronous method. When the operation is finished,
1233 * @callback will be invoked in the
1234 * [thread-default main context][g-main-context-push-thread-default]
1235 * of the thread you are calling this method from. You can
1236 * then call g_dbus_connection_flush_finish() to get the result of the
1237 * operation. See g_dbus_connection_flush_sync() for the synchronous
1243 g_dbus_connection_flush (GDBusConnection
*connection
,
1244 GCancellable
*cancellable
,
1245 GAsyncReadyCallback callback
,
1250 g_return_if_fail (G_IS_DBUS_CONNECTION (connection
));
1252 task
= g_task_new (connection
, cancellable
, callback
, user_data
);
1253 g_task_set_source_tag (task
, g_dbus_connection_flush
);
1254 g_task_run_in_thread (task
, flush_in_thread_func
);
1255 g_object_unref (task
);
1259 * g_dbus_connection_flush_finish:
1260 * @connection: a #GDBusConnection
1261 * @res: a #GAsyncResult obtained from the #GAsyncReadyCallback passed
1262 * to g_dbus_connection_flush()
1263 * @error: return location for error or %NULL
1265 * Finishes an operation started with g_dbus_connection_flush().
1267 * Returns: %TRUE if the operation succeeded, %FALSE if @error is set
1272 g_dbus_connection_flush_finish (GDBusConnection
*connection
,
1276 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), FALSE
);
1277 g_return_val_if_fail (g_task_is_valid (res
, connection
), FALSE
);
1278 g_return_val_if_fail (error
== NULL
|| *error
== NULL
, FALSE
);
1280 return g_task_propagate_boolean (G_TASK (res
), error
);
1284 * g_dbus_connection_flush_sync:
1285 * @connection: a #GDBusConnection
1286 * @cancellable: (nullable): a #GCancellable or %NULL
1287 * @error: return location for error or %NULL
1289 * Synchronously flushes @connection. The calling thread is blocked
1290 * until this is done. See g_dbus_connection_flush() for the
1291 * asynchronous version of this method and more details about what it
1294 * Returns: %TRUE if the operation succeeded, %FALSE if @error is set
1299 g_dbus_connection_flush_sync (GDBusConnection
*connection
,
1300 GCancellable
*cancellable
,
1305 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), FALSE
);
1306 g_return_val_if_fail (error
== NULL
|| *error
== NULL
, FALSE
);
1310 /* This is only a best-effort attempt to see whether the connection is
1311 * closed, so it doesn't need the lock. If the connection closes just
1312 * after this check, but before scheduling the flush operation, the
1313 * result will be more or less the same as if the connection closed while
1314 * the flush operation was pending - it'll fail with either CLOSED or
1317 if (!check_unclosed (connection
, 0, error
))
1320 g_assert (connection
->worker
!= NULL
);
1322 ret
= _g_dbus_worker_flush_sync (connection
->worker
,
1330 /* ---------------------------------------------------------------------------------------------------- */
1334 GDBusConnection
*connection
;
1336 gboolean remote_peer_vanished
;
1340 emit_closed_data_free (EmitClosedData
*data
)
1342 g_object_unref (data
->connection
);
1343 if (data
->error
!= NULL
)
1344 g_error_free (data
->error
);
1348 /* Called in a user thread that has acquired the main context that was
1349 * thread-default when the object was constructed
1352 emit_closed_in_idle (gpointer user_data
)
1354 EmitClosedData
*data
= user_data
;
1357 g_object_notify (G_OBJECT (data
->connection
), "closed");
1358 g_signal_emit (data
->connection
,
1359 signals
[CLOSED_SIGNAL
],
1361 data
->remote_peer_vanished
,
1367 /* Can be called from any thread, must hold lock.
1368 * FLAG_CLOSED must already have been set.
1371 schedule_closed_unlocked (GDBusConnection
*connection
,
1372 gboolean remote_peer_vanished
,
1375 GSource
*idle_source
;
1376 EmitClosedData
*data
;
1378 CONNECTION_ENSURE_LOCK (connection
);
1380 data
= g_new0 (EmitClosedData
, 1);
1381 data
->connection
= g_object_ref (connection
);
1382 data
->remote_peer_vanished
= remote_peer_vanished
;
1383 data
->error
= error
!= NULL
? g_error_copy (error
) : NULL
;
1385 idle_source
= g_idle_source_new ();
1386 g_source_set_priority (idle_source
, G_PRIORITY_DEFAULT
);
1387 g_source_set_callback (idle_source
,
1388 emit_closed_in_idle
,
1390 (GDestroyNotify
) emit_closed_data_free
);
1391 g_source_set_name (idle_source
, "[gio] emit_closed_in_idle");
1392 g_source_attach (idle_source
, connection
->main_context_at_construction
);
1393 g_source_unref (idle_source
);
1396 /* ---------------------------------------------------------------------------------------------------- */
1399 * g_dbus_connection_close:
1400 * @connection: a #GDBusConnection
1401 * @cancellable: (nullable): a #GCancellable or %NULL
1402 * @callback: (nullable): a #GAsyncReadyCallback to call when the request is
1403 * satisfied or %NULL if you don't care about the result
1404 * @user_data: The data to pass to @callback
1406 * Closes @connection. Note that this never causes the process to
1407 * exit (this might only happen if the other end of a shared message
1408 * bus connection disconnects, see #GDBusConnection:exit-on-close).
1410 * Once the connection is closed, operations such as sending a message
1411 * will return with the error %G_IO_ERROR_CLOSED. Closing a connection
1412 * will not automatically flush the connection so queued messages may
1413 * be lost. Use g_dbus_connection_flush() if you need such guarantees.
1415 * If @connection is already closed, this method fails with
1416 * %G_IO_ERROR_CLOSED.
1418 * When @connection has been closed, the #GDBusConnection::closed
1419 * signal is emitted in the
1420 * [thread-default main context][g-main-context-push-thread-default]
1421 * of the thread that @connection was constructed in.
1423 * This is an asynchronous method. When the operation is finished,
1424 * @callback will be invoked in the
1425 * [thread-default main context][g-main-context-push-thread-default]
1426 * of the thread you are calling this method from. You can
1427 * then call g_dbus_connection_close_finish() to get the result of the
1428 * operation. See g_dbus_connection_close_sync() for the synchronous
1434 g_dbus_connection_close (GDBusConnection
*connection
,
1435 GCancellable
*cancellable
,
1436 GAsyncReadyCallback callback
,
1441 g_return_if_fail (G_IS_DBUS_CONNECTION (connection
));
1443 /* do not use g_return_val_if_fail(), we want the memory barrier */
1444 if (!check_initialized (connection
))
1447 g_assert (connection
->worker
!= NULL
);
1449 task
= g_task_new (connection
, cancellable
, callback
, user_data
);
1450 g_task_set_source_tag (task
, g_dbus_connection_close
);
1451 _g_dbus_worker_close (connection
->worker
, task
);
1452 g_object_unref (task
);
1456 * g_dbus_connection_close_finish:
1457 * @connection: a #GDBusConnection
1458 * @res: a #GAsyncResult obtained from the #GAsyncReadyCallback passed
1459 * to g_dbus_connection_close()
1460 * @error: return location for error or %NULL
1462 * Finishes an operation started with g_dbus_connection_close().
1464 * Returns: %TRUE if the operation succeeded, %FALSE if @error is set
1469 g_dbus_connection_close_finish (GDBusConnection
*connection
,
1473 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), FALSE
);
1474 g_return_val_if_fail (g_task_is_valid (res
, connection
), FALSE
);
1475 g_return_val_if_fail (error
== NULL
|| *error
== NULL
, FALSE
);
1477 return g_task_propagate_boolean (G_TASK (res
), error
);
1482 GAsyncResult
*result
;
1485 /* Can be called by any thread, without the connection lock */
1487 sync_close_cb (GObject
*source_object
,
1491 SyncCloseData
*data
= user_data
;
1493 data
->result
= g_object_ref (res
);
1494 g_main_loop_quit (data
->loop
);
1498 * g_dbus_connection_close_sync:
1499 * @connection: a #GDBusConnection
1500 * @cancellable: (nullable): a #GCancellable or %NULL
1501 * @error: return location for error or %NULL
1503 * Synchronously closees @connection. The calling thread is blocked
1504 * until this is done. See g_dbus_connection_close() for the
1505 * asynchronous version of this method and more details about what it
1508 * Returns: %TRUE if the operation succeeded, %FALSE if @error is set
1513 g_dbus_connection_close_sync (GDBusConnection
*connection
,
1514 GCancellable
*cancellable
,
1519 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), FALSE
);
1520 g_return_val_if_fail (error
== NULL
|| *error
== NULL
, FALSE
);
1524 if (check_unclosed (connection
, 0, error
))
1526 GMainContext
*context
;
1529 context
= g_main_context_new ();
1530 g_main_context_push_thread_default (context
);
1531 data
.loop
= g_main_loop_new (context
, TRUE
);
1534 g_dbus_connection_close (connection
, cancellable
, sync_close_cb
, &data
);
1535 g_main_loop_run (data
.loop
);
1536 ret
= g_dbus_connection_close_finish (connection
, data
.result
, error
);
1538 g_object_unref (data
.result
);
1539 g_main_loop_unref (data
.loop
);
1540 g_main_context_pop_thread_default (context
);
1541 g_main_context_unref (context
);
1547 /* ---------------------------------------------------------------------------------------------------- */
1550 * g_dbus_connection_get_last_serial:
1551 * @connection: a #GDBusConnection
1553 * Retrieves the last serial number assigned to a #GDBusMessage on
1554 * the current thread. This includes messages sent via both low-level
1555 * API such as g_dbus_connection_send_message() as well as
1556 * high-level API such as g_dbus_connection_emit_signal(),
1557 * g_dbus_connection_call() or g_dbus_proxy_call().
1559 * Returns: the last used serial or zero when no message has been sent
1560 * within the current thread
1565 g_dbus_connection_get_last_serial (GDBusConnection
*connection
)
1569 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), 0);
1571 CONNECTION_LOCK (connection
);
1572 ret
= GPOINTER_TO_UINT (g_hash_table_lookup (connection
->map_thread_to_last_serial
,
1574 CONNECTION_UNLOCK (connection
);
1579 /* ---------------------------------------------------------------------------------------------------- */
1581 /* Can be called by any thread, with the connection lock held */
1583 g_dbus_connection_send_message_unlocked (GDBusConnection
*connection
,
1584 GDBusMessage
*message
,
1585 GDBusSendMessageFlags flags
,
1586 volatile guint32
*out_serial
,
1591 guint32 serial_to_use
;
1594 CONNECTION_ENSURE_LOCK (connection
);
1596 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), FALSE
);
1597 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message
), FALSE
);
1599 /* TODO: check all necessary headers are present */
1604 if (out_serial
!= NULL
)
1607 /* If we're in initable_init(), don't check for being initialized, to avoid
1608 * chicken-and-egg problems. initable_init() is responsible for setting up
1609 * our prerequisites (mainly connection->worker), and only calling us
1610 * from its own thread (so no memory barrier is needed).
1612 if (!check_unclosed (connection
,
1613 (flags
& SEND_MESSAGE_FLAGS_INITIALIZING
) ? MAY_BE_UNINITIALIZED
: 0,
1617 blob
= g_dbus_message_to_blob (message
,
1619 connection
->capabilities
,
1624 if (flags
& G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL
)
1625 serial_to_use
= g_dbus_message_get_serial (message
);
1627 serial_to_use
= ++connection
->last_serial
; /* TODO: handle overflow */
1632 ((guint32
*) blob
)[2] = GUINT32_TO_LE (serial_to_use
);
1635 ((guint32
*) blob
)[2] = GUINT32_TO_BE (serial_to_use
);
1638 g_assert_not_reached ();
1643 g_printerr ("Writing message of %" G_GSIZE_FORMAT
" bytes (serial %d) on %p:\n",
1644 blob_size
, serial_to_use
, connection
);
1645 g_printerr ("----\n");
1646 hexdump (blob
, blob_size
);
1647 g_printerr ("----\n");
1650 /* TODO: use connection->auth to encode the blob */
1652 if (out_serial
!= NULL
)
1653 *out_serial
= serial_to_use
;
1655 /* store used serial for the current thread */
1656 /* TODO: watch the thread disposal and remove associated record
1658 * - see https://bugzilla.gnome.org/show_bug.cgi?id=676825#c7
1660 g_hash_table_replace (connection
->map_thread_to_last_serial
,
1662 GUINT_TO_POINTER (serial_to_use
));
1664 if (!(flags
& G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL
))
1665 g_dbus_message_set_serial (message
, serial_to_use
);
1667 g_dbus_message_lock (message
);
1668 _g_dbus_worker_send_message (connection
->worker
,
1672 blob
= NULL
; /* since _g_dbus_worker_send_message() steals the blob */
1683 * g_dbus_connection_send_message:
1684 * @connection: a #GDBusConnection
1685 * @message: a #GDBusMessage
1686 * @flags: flags affecting how the message is sent
1687 * @out_serial: (out) (optional): return location for serial number assigned
1688 * to @message when sending it or %NULL
1689 * @error: Return location for error or %NULL
1691 * Asynchronously sends @message to the peer represented by @connection.
1693 * Unless @flags contain the
1694 * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number
1695 * will be assigned by @connection and set on @message via
1696 * g_dbus_message_set_serial(). If @out_serial is not %NULL, then the
1697 * serial number used will be written to this location prior to
1698 * submitting the message to the underlying transport.
1700 * If @connection is closed then the operation will fail with
1701 * %G_IO_ERROR_CLOSED. If @message is not well-formed,
1702 * the operation fails with %G_IO_ERROR_INVALID_ARGUMENT.
1704 * See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
1705 * for an example of how to use this low-level API to send and receive
1706 * UNIX file descriptors.
1708 * Note that @message must be unlocked, unless @flags contain the
1709 * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
1711 * Returns: %TRUE if the message was well-formed and queued for
1712 * transmission, %FALSE if @error is set
1717 g_dbus_connection_send_message (GDBusConnection
*connection
,
1718 GDBusMessage
*message
,
1719 GDBusSendMessageFlags flags
,
1720 volatile guint32
*out_serial
,
1725 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), FALSE
);
1726 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message
), FALSE
);
1727 g_return_val_if_fail ((flags
& G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL
) || !g_dbus_message_get_locked (message
), FALSE
);
1728 g_return_val_if_fail (error
== NULL
|| *error
== NULL
, FALSE
);
1730 CONNECTION_LOCK (connection
);
1731 ret
= g_dbus_connection_send_message_unlocked (connection
, message
, flags
, out_serial
, error
);
1732 CONNECTION_UNLOCK (connection
);
1736 /* ---------------------------------------------------------------------------------------------------- */
1742 gulong cancellable_handler_id
;
1744 GSource
*timeout_source
;
1749 /* Can be called from any thread with or without lock held */
1751 send_message_data_free (SendMessageData
*data
)
1753 g_assert (data
->timeout_source
== NULL
);
1754 g_assert (data
->cancellable_handler_id
== 0);
1756 g_slice_free (SendMessageData
, data
);
1759 /* ---------------------------------------------------------------------------------------------------- */
1761 /* can be called from any thread with lock held; @task is (transfer full) */
1763 send_message_with_reply_cleanup (GTask
*task
, gboolean remove
)
1765 GDBusConnection
*connection
= g_task_get_source_object (task
);
1766 SendMessageData
*data
= g_task_get_task_data (task
);
1768 CONNECTION_ENSURE_LOCK (connection
);
1770 g_assert (!data
->delivered
);
1772 data
->delivered
= TRUE
;
1774 if (data
->timeout_source
!= NULL
)
1776 g_source_destroy (data
->timeout_source
);
1777 data
->timeout_source
= NULL
;
1779 if (data
->cancellable_handler_id
> 0)
1781 g_cancellable_disconnect (g_task_get_cancellable (task
), data
->cancellable_handler_id
);
1782 data
->cancellable_handler_id
= 0;
1787 gboolean removed
= g_hash_table_remove (connection
->map_method_serial_to_task
,
1788 GUINT_TO_POINTER (data
->serial
));
1789 g_warn_if_fail (removed
);
1792 g_object_unref (task
);
1795 /* ---------------------------------------------------------------------------------------------------- */
1797 /* Called from GDBus worker thread with lock held; @task is (transfer full). */
1799 send_message_data_deliver_reply_unlocked (GTask
*task
,
1800 GDBusMessage
*reply
)
1802 SendMessageData
*data
= g_task_get_task_data (task
);
1804 if (data
->delivered
)
1807 g_task_return_pointer (task
, g_object_ref (reply
), g_object_unref
);
1809 send_message_with_reply_cleanup (task
, TRUE
);
1815 /* Called from a user thread, lock is not held */
1817 send_message_data_deliver_error (GTask
*task
,
1820 const char *message
)
1822 GDBusConnection
*connection
= g_task_get_source_object (task
);
1823 SendMessageData
*data
= g_task_get_task_data (task
);
1825 CONNECTION_LOCK (connection
);
1826 if (data
->delivered
)
1828 CONNECTION_UNLOCK (connection
);
1832 g_object_ref (task
);
1833 send_message_with_reply_cleanup (task
, TRUE
);
1834 CONNECTION_UNLOCK (connection
);
1836 g_task_return_new_error (task
, domain
, code
, "%s", message
);
1837 g_object_unref (task
);
1840 /* ---------------------------------------------------------------------------------------------------- */
1842 /* Called from a user thread, lock is not held; @task is (transfer full) */
1844 send_message_with_reply_cancelled_idle_cb (gpointer user_data
)
1846 GTask
*task
= user_data
;
1848 send_message_data_deliver_error (task
, G_IO_ERROR
, G_IO_ERROR_CANCELLED
,
1849 _("Operation was cancelled"));
1853 /* Can be called from any thread with or without lock held */
1855 send_message_with_reply_cancelled_cb (GCancellable
*cancellable
,
1858 GTask
*task
= user_data
;
1859 GSource
*idle_source
;
1861 /* postpone cancellation to idle handler since we may be called directly
1862 * via g_cancellable_connect() (e.g. holding lock)
1864 idle_source
= g_idle_source_new ();
1865 g_source_set_name (idle_source
, "[gio] send_message_with_reply_cancelled_idle_cb");
1866 g_task_attach_source (task
, idle_source
, send_message_with_reply_cancelled_idle_cb
);
1867 g_source_unref (idle_source
);
1870 /* ---------------------------------------------------------------------------------------------------- */
1872 /* Called from a user thread, lock is not held; @task is (transfer full) */
1874 send_message_with_reply_timeout_cb (gpointer user_data
)
1876 GTask
*task
= user_data
;
1878 send_message_data_deliver_error (task
, G_IO_ERROR
, G_IO_ERROR_TIMED_OUT
,
1879 _("Timeout was reached"));
1883 /* ---------------------------------------------------------------------------------------------------- */
1885 /* Called from a user thread, connection's lock is held */
1887 g_dbus_connection_send_message_with_reply_unlocked (GDBusConnection
*connection
,
1888 GDBusMessage
*message
,
1889 GDBusSendMessageFlags flags
,
1891 volatile guint32
*out_serial
,
1892 GCancellable
*cancellable
,
1893 GAsyncReadyCallback callback
,
1897 SendMessageData
*data
;
1898 GError
*error
= NULL
;
1899 volatile guint32 serial
;
1901 if (out_serial
== NULL
)
1902 out_serial
= &serial
;
1904 if (timeout_msec
== -1)
1905 timeout_msec
= 25 * 1000;
1907 data
= g_slice_new0 (SendMessageData
);
1908 task
= g_task_new (connection
, cancellable
, callback
, user_data
);
1909 g_task_set_source_tag (task
,
1910 g_dbus_connection_send_message_with_reply_unlocked
);
1911 g_task_set_task_data (task
, data
, (GDestroyNotify
) send_message_data_free
);
1913 if (g_task_return_error_if_cancelled (task
))
1915 g_object_unref (task
);
1919 if (!g_dbus_connection_send_message_unlocked (connection
, message
, flags
, out_serial
, &error
))
1921 g_task_return_error (task
, error
);
1922 g_object_unref (task
);
1925 data
->serial
= *out_serial
;
1927 if (cancellable
!= NULL
)
1929 data
->cancellable_handler_id
= g_cancellable_connect (cancellable
,
1930 G_CALLBACK (send_message_with_reply_cancelled_cb
),
1931 g_object_ref (task
),
1935 if (timeout_msec
!= G_MAXINT
)
1937 data
->timeout_source
= g_timeout_source_new (timeout_msec
);
1938 g_task_attach_source (task
, data
->timeout_source
,
1939 (GSourceFunc
) send_message_with_reply_timeout_cb
);
1940 g_source_unref (data
->timeout_source
);
1943 g_hash_table_insert (connection
->map_method_serial_to_task
,
1944 GUINT_TO_POINTER (*out_serial
),
1945 g_steal_pointer (&task
));
1949 * g_dbus_connection_send_message_with_reply:
1950 * @connection: a #GDBusConnection
1951 * @message: a #GDBusMessage
1952 * @flags: flags affecting how the message is sent
1953 * @timeout_msec: the timeout in milliseconds, -1 to use the default
1954 * timeout or %G_MAXINT for no timeout
1955 * @out_serial: (out) (optional): return location for serial number assigned
1956 * to @message when sending it or %NULL
1957 * @cancellable: (nullable): a #GCancellable or %NULL
1958 * @callback: (nullable): a #GAsyncReadyCallback to call when the request
1959 * is satisfied or %NULL if you don't care about the result
1960 * @user_data: The data to pass to @callback
1962 * Asynchronously sends @message to the peer represented by @connection.
1964 * Unless @flags contain the
1965 * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number
1966 * will be assigned by @connection and set on @message via
1967 * g_dbus_message_set_serial(). If @out_serial is not %NULL, then the
1968 * serial number used will be written to this location prior to
1969 * submitting the message to the underlying transport.
1971 * If @connection is closed then the operation will fail with
1972 * %G_IO_ERROR_CLOSED. If @cancellable is canceled, the operation will
1973 * fail with %G_IO_ERROR_CANCELLED. If @message is not well-formed,
1974 * the operation fails with %G_IO_ERROR_INVALID_ARGUMENT.
1976 * This is an asynchronous method. When the operation is finished, @callback
1977 * will be invoked in the
1978 * [thread-default main context][g-main-context-push-thread-default]
1979 * of the thread you are calling this method from. You can then call
1980 * g_dbus_connection_send_message_with_reply_finish() to get the result of the operation.
1981 * See g_dbus_connection_send_message_with_reply_sync() for the synchronous version.
1983 * Note that @message must be unlocked, unless @flags contain the
1984 * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
1986 * See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
1987 * for an example of how to use this low-level API to send and receive
1988 * UNIX file descriptors.
1993 g_dbus_connection_send_message_with_reply (GDBusConnection
*connection
,
1994 GDBusMessage
*message
,
1995 GDBusSendMessageFlags flags
,
1997 volatile guint32
*out_serial
,
1998 GCancellable
*cancellable
,
1999 GAsyncReadyCallback callback
,
2002 g_return_if_fail (G_IS_DBUS_CONNECTION (connection
));
2003 g_return_if_fail (G_IS_DBUS_MESSAGE (message
));
2004 g_return_if_fail ((flags
& G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL
) || !g_dbus_message_get_locked (message
));
2005 g_return_if_fail (timeout_msec
>= 0 || timeout_msec
== -1);
2007 CONNECTION_LOCK (connection
);
2008 g_dbus_connection_send_message_with_reply_unlocked (connection
,
2016 CONNECTION_UNLOCK (connection
);
2020 * g_dbus_connection_send_message_with_reply_finish:
2021 * @connection: a #GDBusConnection
2022 * @res: a #GAsyncResult obtained from the #GAsyncReadyCallback passed to
2023 * g_dbus_connection_send_message_with_reply()
2024 * @error: teturn location for error or %NULL
2026 * Finishes an operation started with g_dbus_connection_send_message_with_reply().
2028 * Note that @error is only set if a local in-process error
2029 * occurred. That is to say that the returned #GDBusMessage object may
2030 * be of type %G_DBUS_MESSAGE_TYPE_ERROR. Use
2031 * g_dbus_message_to_gerror() to transcode this to a #GError.
2033 * See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
2034 * for an example of how to use this low-level API to send and receive
2035 * UNIX file descriptors.
2037 * Returns: (transfer full): a locked #GDBusMessage or %NULL if @error is set
2042 g_dbus_connection_send_message_with_reply_finish (GDBusConnection
*connection
,
2046 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), NULL
);
2047 g_return_val_if_fail (g_task_is_valid (res
, connection
), NULL
);
2048 g_return_val_if_fail (error
== NULL
|| *error
== NULL
, NULL
);
2050 return g_task_propagate_pointer (G_TASK (res
), error
);
2053 /* ---------------------------------------------------------------------------------------------------- */
2058 GMainContext
*context
;
2060 } SendMessageSyncData
;
2062 /* Called from a user thread, lock is not held */
2064 send_message_with_reply_sync_cb (GDBusConnection
*connection
,
2068 SendMessageSyncData
*data
= user_data
;
2069 data
->res
= g_object_ref (res
);
2070 g_main_loop_quit (data
->loop
);
2074 * g_dbus_connection_send_message_with_reply_sync:
2075 * @connection: a #GDBusConnection
2076 * @message: a #GDBusMessage
2077 * @flags: flags affecting how the message is sent.
2078 * @timeout_msec: the timeout in milliseconds, -1 to use the default
2079 * timeout or %G_MAXINT for no timeout
2080 * @out_serial: (out) (optional): return location for serial number
2081 * assigned to @message when sending it or %NULL
2082 * @cancellable: (nullable): a #GCancellable or %NULL
2083 * @error: return location for error or %NULL
2085 * Synchronously sends @message to the peer represented by @connection
2086 * and blocks the calling thread until a reply is received or the
2087 * timeout is reached. See g_dbus_connection_send_message_with_reply()
2088 * for the asynchronous version of this method.
2090 * Unless @flags contain the
2091 * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number
2092 * will be assigned by @connection and set on @message via
2093 * g_dbus_message_set_serial(). If @out_serial is not %NULL, then the
2094 * serial number used will be written to this location prior to
2095 * submitting the message to the underlying transport.
2097 * If @connection is closed then the operation will fail with
2098 * %G_IO_ERROR_CLOSED. If @cancellable is canceled, the operation will
2099 * fail with %G_IO_ERROR_CANCELLED. If @message is not well-formed,
2100 * the operation fails with %G_IO_ERROR_INVALID_ARGUMENT.
2102 * Note that @error is only set if a local in-process error
2103 * occurred. That is to say that the returned #GDBusMessage object may
2104 * be of type %G_DBUS_MESSAGE_TYPE_ERROR. Use
2105 * g_dbus_message_to_gerror() to transcode this to a #GError.
2107 * See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
2108 * for an example of how to use this low-level API to send and receive
2109 * UNIX file descriptors.
2111 * Note that @message must be unlocked, unless @flags contain the
2112 * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
2114 * Returns: (transfer full): a locked #GDBusMessage that is the reply
2115 * to @message or %NULL if @error is set
2120 g_dbus_connection_send_message_with_reply_sync (GDBusConnection
*connection
,
2121 GDBusMessage
*message
,
2122 GDBusSendMessageFlags flags
,
2124 volatile guint32
*out_serial
,
2125 GCancellable
*cancellable
,
2128 SendMessageSyncData data
;
2129 GDBusMessage
*reply
;
2131 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), NULL
);
2132 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message
), NULL
);
2133 g_return_val_if_fail ((flags
& G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL
) || !g_dbus_message_get_locked (message
), NULL
);
2134 g_return_val_if_fail (timeout_msec
>= 0 || timeout_msec
== -1, NULL
);
2135 g_return_val_if_fail (error
== NULL
|| *error
== NULL
, NULL
);
2138 data
.context
= g_main_context_new ();
2139 data
.loop
= g_main_loop_new (data
.context
, FALSE
);
2141 g_main_context_push_thread_default (data
.context
);
2143 g_dbus_connection_send_message_with_reply (connection
,
2149 (GAsyncReadyCallback
) send_message_with_reply_sync_cb
,
2151 g_main_loop_run (data
.loop
);
2152 reply
= g_dbus_connection_send_message_with_reply_finish (connection
,
2156 g_main_context_pop_thread_default (data
.context
);
2158 g_main_context_unref (data
.context
);
2159 g_main_loop_unref (data
.loop
);
2161 g_object_unref (data
.res
);
2166 /* ---------------------------------------------------------------------------------------------------- */
2172 GDBusMessageFilterFunction filter_function
;
2174 GDestroyNotify user_data_free_func
;
2175 GMainContext
*context
;
2178 /* requires CONNECTION_LOCK */
2179 static FilterData
**
2180 copy_filter_list (GPtrArray
*filters
)
2185 copy
= g_new (FilterData
*, filters
->len
+ 1);
2186 for (n
= 0; n
< filters
->len
; n
++)
2188 copy
[n
] = filters
->pdata
[n
];
2189 copy
[n
]->ref_count
++;
2196 /* requires CONNECTION_LOCK */
2198 free_filter_list (FilterData
**filters
)
2202 for (n
= 0; filters
[n
]; n
++)
2204 filters
[n
]->ref_count
--;
2205 if (filters
[n
]->ref_count
== 0)
2207 call_destroy_notify (filters
[n
]->context
,
2208 filters
[n
]->user_data_free_func
,
2209 filters
[n
]->user_data
);
2210 g_main_context_unref (filters
[n
]->context
);
2211 g_free (filters
[n
]);
2217 /* Called in GDBusWorker's thread - we must not block - with no lock held */
2219 on_worker_message_received (GDBusWorker
*worker
,
2220 GDBusMessage
*message
,
2223 GDBusConnection
*connection
;
2224 FilterData
**filters
;
2228 G_LOCK (message_bus_lock
);
2229 alive
= (g_hash_table_lookup (alive_connections
, user_data
) != NULL
);
2232 G_UNLOCK (message_bus_lock
);
2235 connection
= G_DBUS_CONNECTION (user_data
);
2236 g_object_ref (connection
);
2237 G_UNLOCK (message_bus_lock
);
2239 //g_debug ("in on_worker_message_received");
2241 g_object_ref (message
);
2242 g_dbus_message_lock (message
);
2244 //g_debug ("boo ref_count = %d %p %p", G_OBJECT (connection)->ref_count, connection, connection->worker);
2246 /* First collect the set of callback functions */
2247 CONNECTION_LOCK (connection
);
2248 filters
= copy_filter_list (connection
->filters
);
2249 CONNECTION_UNLOCK (connection
);
2251 /* then call the filters in order (without holding the lock) */
2252 for (n
= 0; filters
[n
]; n
++)
2254 message
= filters
[n
]->filter_function (connection
,
2257 filters
[n
]->user_data
);
2258 if (message
== NULL
)
2260 g_dbus_message_lock (message
);
2263 CONNECTION_LOCK (connection
);
2264 free_filter_list (filters
);
2265 CONNECTION_UNLOCK (connection
);
2267 /* Standard dispatch unless the filter ate the message - no need to
2268 * do anything if the message was altered
2270 if (message
!= NULL
)
2272 GDBusMessageType message_type
;
2274 message_type
= g_dbus_message_get_message_type (message
);
2275 if (message_type
== G_DBUS_MESSAGE_TYPE_METHOD_RETURN
|| message_type
== G_DBUS_MESSAGE_TYPE_ERROR
)
2277 guint32 reply_serial
;
2280 reply_serial
= g_dbus_message_get_reply_serial (message
);
2281 CONNECTION_LOCK (connection
);
2282 task
= g_hash_table_lookup (connection
->map_method_serial_to_task
,
2283 GUINT_TO_POINTER (reply_serial
));
2286 /* This removes @task from @map_method_serial_to_task. */
2287 //g_debug ("delivering reply/error for serial %d for %p", reply_serial, connection);
2288 send_message_data_deliver_reply_unlocked (task
, message
);
2292 //g_debug ("message reply/error for serial %d but no SendMessageData found for %p", reply_serial, connection);
2294 CONNECTION_UNLOCK (connection
);
2296 else if (message_type
== G_DBUS_MESSAGE_TYPE_SIGNAL
)
2298 CONNECTION_LOCK (connection
);
2299 distribute_signals (connection
, message
);
2300 CONNECTION_UNLOCK (connection
);
2302 else if (message_type
== G_DBUS_MESSAGE_TYPE_METHOD_CALL
)
2304 CONNECTION_LOCK (connection
);
2305 distribute_method_call (connection
, message
);
2306 CONNECTION_UNLOCK (connection
);
2310 if (message
!= NULL
)
2311 g_object_unref (message
);
2312 g_object_unref (connection
);
2315 /* Called in GDBusWorker's thread, lock is not held */
2316 static GDBusMessage
*
2317 on_worker_message_about_to_be_sent (GDBusWorker
*worker
,
2318 GDBusMessage
*message
,
2321 GDBusConnection
*connection
;
2322 FilterData
**filters
;
2326 G_LOCK (message_bus_lock
);
2327 alive
= (g_hash_table_lookup (alive_connections
, user_data
) != NULL
);
2330 G_UNLOCK (message_bus_lock
);
2333 connection
= G_DBUS_CONNECTION (user_data
);
2334 g_object_ref (connection
);
2335 G_UNLOCK (message_bus_lock
);
2337 //g_debug ("in on_worker_message_about_to_be_sent");
2339 /* First collect the set of callback functions */
2340 CONNECTION_LOCK (connection
);
2341 filters
= copy_filter_list (connection
->filters
);
2342 CONNECTION_UNLOCK (connection
);
2344 /* then call the filters in order (without holding the lock) */
2345 for (n
= 0; filters
[n
]; n
++)
2347 g_dbus_message_lock (message
);
2348 message
= filters
[n
]->filter_function (connection
,
2351 filters
[n
]->user_data
);
2352 if (message
== NULL
)
2356 CONNECTION_LOCK (connection
);
2357 free_filter_list (filters
);
2358 CONNECTION_UNLOCK (connection
);
2360 g_object_unref (connection
);
2365 /* called with connection lock held, in GDBusWorker thread */
2367 cancel_method_on_close (gpointer key
, gpointer value
, gpointer user_data
)
2369 GTask
*task
= value
;
2370 SendMessageData
*data
= g_task_get_task_data (task
);
2372 if (data
->delivered
)
2375 g_task_return_new_error (task
,
2378 _("The connection is closed"));
2380 /* Ask send_message_with_reply_cleanup not to remove the element from the
2381 * hash table - we're in the middle of a foreach; that would be unsafe.
2382 * Instead, return TRUE from this function so that it gets removed safely.
2384 send_message_with_reply_cleanup (task
, FALSE
);
2388 /* Called in GDBusWorker's thread - we must not block - without lock held */
2390 on_worker_closed (GDBusWorker
*worker
,
2391 gboolean remote_peer_vanished
,
2395 GDBusConnection
*connection
;
2397 guint old_atomic_flags
;
2399 G_LOCK (message_bus_lock
);
2400 alive
= (g_hash_table_lookup (alive_connections
, user_data
) != NULL
);
2403 G_UNLOCK (message_bus_lock
);
2406 connection
= G_DBUS_CONNECTION (user_data
);
2407 g_object_ref (connection
);
2408 G_UNLOCK (message_bus_lock
);
2410 //g_debug ("in on_worker_closed: %s", error->message);
2412 CONNECTION_LOCK (connection
);
2413 /* Even though this is atomic, we do it inside the lock to avoid breaking
2414 * assumptions in remove_match_rule(). We'd need the lock in a moment
2415 * anyway, so, no loss.
2417 old_atomic_flags
= g_atomic_int_or (&connection
->atomic_flags
, FLAG_CLOSED
);
2419 if (!(old_atomic_flags
& FLAG_CLOSED
))
2421 g_hash_table_foreach_remove (connection
->map_method_serial_to_task
, cancel_method_on_close
, NULL
);
2422 schedule_closed_unlocked (connection
, remote_peer_vanished
, error
);
2424 CONNECTION_UNLOCK (connection
);
2426 g_object_unref (connection
);
2429 /* ---------------------------------------------------------------------------------------------------- */
2431 /* Determines the biggest set of capabilities we can support on this
2434 * Called with the init_lock held.
2436 static GDBusCapabilityFlags
2437 get_offered_capabilities_max (GDBusConnection
*connection
)
2439 GDBusCapabilityFlags ret
;
2440 ret
= G_DBUS_CAPABILITY_FLAGS_NONE
;
2442 if (G_IS_UNIX_CONNECTION (connection
->stream
))
2443 ret
|= G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING
;
2448 /* Called in a user thread, lock is not held */
2450 initable_init (GInitable
*initable
,
2451 GCancellable
*cancellable
,
2454 GDBusConnection
*connection
= G_DBUS_CONNECTION (initable
);
2457 /* This method needs to be idempotent to work with the singleton
2458 * pattern. See the docs for g_initable_init(). We implement this by
2461 * Unfortunately we can't use the main lock since the on_worker_*()
2462 * callbacks above needs the lock during initialization (for message
2463 * bus connections we do a synchronous Hello() call on the bus).
2465 g_mutex_lock (&connection
->init_lock
);
2469 /* Make this a no-op if we're already initialized (successfully or
2472 if ((g_atomic_int_get (&connection
->atomic_flags
) & FLAG_INITIALIZED
))
2474 ret
= (connection
->initialization_error
== NULL
);
2478 /* Because of init_lock, we can't get here twice in different threads */
2479 g_assert (connection
->initialization_error
== NULL
);
2481 /* The user can pass multiple (but mutally exclusive) construct
2484 * - stream (of type GIOStream)
2485 * - address (of type gchar*)
2487 * At the end of the day we end up with a non-NULL GIOStream
2488 * object in connection->stream.
2490 if (connection
->address
!= NULL
)
2492 g_assert (connection
->stream
== NULL
);
2494 if ((connection
->flags
& G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER
) ||
2495 (connection
->flags
& G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS
))
2497 g_set_error_literal (&connection
->initialization_error
,
2499 G_IO_ERROR_INVALID_ARGUMENT
,
2500 _("Unsupported flags encountered when constructing a client-side connection"));
2504 connection
->stream
= g_dbus_address_get_stream_sync (connection
->address
,
2505 NULL
, /* TODO: out_guid */
2507 &connection
->initialization_error
);
2508 if (connection
->stream
== NULL
)
2511 else if (connection
->stream
!= NULL
)
2517 g_assert_not_reached ();
2520 /* Authenticate the connection */
2521 if (connection
->flags
& G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER
)
2523 g_assert (!(connection
->flags
& G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT
));
2524 g_assert (connection
->guid
!= NULL
);
2525 connection
->auth
= _g_dbus_auth_new (connection
->stream
);
2526 if (!_g_dbus_auth_run_server (connection
->auth
,
2527 connection
->authentication_observer
,
2529 (connection
->flags
& G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS
),
2530 get_offered_capabilities_max (connection
),
2531 &connection
->capabilities
,
2532 &connection
->credentials
,
2534 &connection
->initialization_error
))
2537 else if (connection
->flags
& G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT
)
2539 g_assert (!(connection
->flags
& G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER
));
2540 g_assert (connection
->guid
== NULL
);
2541 connection
->auth
= _g_dbus_auth_new (connection
->stream
);
2542 connection
->guid
= _g_dbus_auth_run_client (connection
->auth
,
2543 connection
->authentication_observer
,
2544 get_offered_capabilities_max (connection
),
2545 &connection
->capabilities
,
2547 &connection
->initialization_error
);
2548 if (connection
->guid
== NULL
)
2552 if (connection
->authentication_observer
!= NULL
)
2554 g_object_unref (connection
->authentication_observer
);
2555 connection
->authentication_observer
= NULL
;
2558 //g_output_stream_flush (G_SOCKET_CONNECTION (connection->stream)
2560 //g_debug ("haz unix fd passing powers: %d", connection->capabilities & G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING);
2563 /* We want all IO operations to be non-blocking since they happen in
2564 * the worker thread which is shared by _all_ connections.
2566 if (G_IS_SOCKET_CONNECTION (connection
->stream
))
2568 g_socket_set_blocking (g_socket_connection_get_socket (G_SOCKET_CONNECTION (connection
->stream
)), FALSE
);
2572 G_LOCK (message_bus_lock
);
2573 if (alive_connections
== NULL
)
2574 alive_connections
= g_hash_table_new (g_direct_hash
, g_direct_equal
);
2575 g_hash_table_insert (alive_connections
, connection
, connection
);
2576 G_UNLOCK (message_bus_lock
);
2578 connection
->worker
= _g_dbus_worker_new (connection
->stream
,
2579 connection
->capabilities
,
2580 ((connection
->flags
& G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING
) != 0),
2581 on_worker_message_received
,
2582 on_worker_message_about_to_be_sent
,
2586 /* if a bus connection, call org.freedesktop.DBus.Hello - this is how we're getting a name */
2587 if (connection
->flags
& G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION
)
2589 GVariant
*hello_result
;
2591 /* we could lift this restriction by adding code in gdbusprivate.c */
2592 if (connection
->flags
& G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING
)
2594 g_set_error_literal (&connection
->initialization_error
,
2597 "Cannot use DELAY_MESSAGE_PROCESSING with MESSAGE_BUS_CONNECTION");
2601 hello_result
= g_dbus_connection_call_sync (connection
,
2602 "org.freedesktop.DBus", /* name */
2603 "/org/freedesktop/DBus", /* path */
2604 "org.freedesktop.DBus", /* interface */
2606 NULL
, /* parameters */
2607 G_VARIANT_TYPE ("(s)"),
2608 CALL_FLAGS_INITIALIZING
,
2610 NULL
, /* TODO: cancellable */
2611 &connection
->initialization_error
);
2612 if (hello_result
== NULL
)
2615 g_variant_get (hello_result
, "(s)", &connection
->bus_unique_name
);
2616 g_variant_unref (hello_result
);
2617 //g_debug ("unique name is '%s'", connection->bus_unique_name);
2624 g_assert (connection
->initialization_error
!= NULL
);
2625 g_propagate_error (error
, g_error_copy (connection
->initialization_error
));
2628 g_atomic_int_or (&connection
->atomic_flags
, FLAG_INITIALIZED
);
2629 g_mutex_unlock (&connection
->init_lock
);
2635 initable_iface_init (GInitableIface
*initable_iface
)
2637 initable_iface
->init
= initable_init
;
2640 /* ---------------------------------------------------------------------------------------------------- */
2643 async_initable_iface_init (GAsyncInitableIface
*async_initable_iface
)
2648 /* ---------------------------------------------------------------------------------------------------- */
2651 * g_dbus_connection_new:
2652 * @stream: a #GIOStream
2653 * @guid: (nullable): the GUID to use if a authenticating as a server or %NULL
2654 * @flags: flags describing how to make the connection
2655 * @observer: (nullable): a #GDBusAuthObserver or %NULL
2656 * @cancellable: (nullable): a #GCancellable or %NULL
2657 * @callback: a #GAsyncReadyCallback to call when the request is satisfied
2658 * @user_data: the data to pass to @callback
2660 * Asynchronously sets up a D-Bus connection for exchanging D-Bus messages
2661 * with the end represented by @stream.
2663 * If @stream is a #GSocketConnection, then the corresponding #GSocket
2664 * will be put into non-blocking mode.
2666 * The D-Bus connection will interact with @stream from a worker thread.
2667 * As a result, the caller should not interact with @stream after this
2668 * method has been called, except by calling g_object_unref() on it.
2670 * If @observer is not %NULL it may be used to control the
2671 * authentication process.
2673 * When the operation is finished, @callback will be invoked. You can
2674 * then call g_dbus_connection_new_finish() to get the result of the
2677 * This is a asynchronous failable constructor. See
2678 * g_dbus_connection_new_sync() for the synchronous
2684 g_dbus_connection_new (GIOStream
*stream
,
2686 GDBusConnectionFlags flags
,
2687 GDBusAuthObserver
*observer
,
2688 GCancellable
*cancellable
,
2689 GAsyncReadyCallback callback
,
2692 _g_dbus_initialize ();
2694 g_return_if_fail (G_IS_IO_STREAM (stream
));
2696 g_async_initable_new_async (G_TYPE_DBUS_CONNECTION
,
2704 "authentication-observer", observer
,
2709 * g_dbus_connection_new_finish:
2710 * @res: a #GAsyncResult obtained from the #GAsyncReadyCallback
2711 * passed to g_dbus_connection_new().
2712 * @error: return location for error or %NULL
2714 * Finishes an operation started with g_dbus_connection_new().
2716 * Returns: a #GDBusConnection or %NULL if @error is set. Free
2717 * with g_object_unref().
2722 g_dbus_connection_new_finish (GAsyncResult
*res
,
2726 GObject
*source_object
;
2728 g_return_val_if_fail (G_IS_ASYNC_RESULT (res
), NULL
);
2729 g_return_val_if_fail (error
== NULL
|| *error
== NULL
, NULL
);
2731 source_object
= g_async_result_get_source_object (res
);
2732 g_assert (source_object
!= NULL
);
2733 object
= g_async_initable_new_finish (G_ASYNC_INITABLE (source_object
),
2736 g_object_unref (source_object
);
2738 return G_DBUS_CONNECTION (object
);
2744 * g_dbus_connection_new_sync:
2745 * @stream: a #GIOStream
2746 * @guid: (nullable): the GUID to use if a authenticating as a server or %NULL
2747 * @flags: flags describing how to make the connection
2748 * @observer: (nullable): a #GDBusAuthObserver or %NULL
2749 * @cancellable: (nullable): a #GCancellable or %NULL
2750 * @error: return location for error or %NULL
2752 * Synchronously sets up a D-Bus connection for exchanging D-Bus messages
2753 * with the end represented by @stream.
2755 * If @stream is a #GSocketConnection, then the corresponding #GSocket
2756 * will be put into non-blocking mode.
2758 * The D-Bus connection will interact with @stream from a worker thread.
2759 * As a result, the caller should not interact with @stream after this
2760 * method has been called, except by calling g_object_unref() on it.
2762 * If @observer is not %NULL it may be used to control the
2763 * authentication process.
2765 * This is a synchronous failable constructor. See
2766 * g_dbus_connection_new() for the asynchronous version.
2768 * Returns: a #GDBusConnection or %NULL if @error is set. Free with g_object_unref().
2773 g_dbus_connection_new_sync (GIOStream
*stream
,
2775 GDBusConnectionFlags flags
,
2776 GDBusAuthObserver
*observer
,
2777 GCancellable
*cancellable
,
2780 _g_dbus_initialize ();
2781 g_return_val_if_fail (G_IS_IO_STREAM (stream
), NULL
);
2782 g_return_val_if_fail (error
== NULL
|| *error
== NULL
, NULL
);
2783 return g_initable_new (G_TYPE_DBUS_CONNECTION
,
2789 "authentication-observer", observer
,
2793 /* ---------------------------------------------------------------------------------------------------- */
2796 * g_dbus_connection_new_for_address:
2797 * @address: a D-Bus address
2798 * @flags: flags describing how to make the connection
2799 * @observer: (nullable): a #GDBusAuthObserver or %NULL
2800 * @cancellable: (nullable): a #GCancellable or %NULL
2801 * @callback: a #GAsyncReadyCallback to call when the request is satisfied
2802 * @user_data: the data to pass to @callback
2804 * Asynchronously connects and sets up a D-Bus client connection for
2805 * exchanging D-Bus messages with an endpoint specified by @address
2806 * which must be in the
2807 * [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
2809 * This constructor can only be used to initiate client-side
2810 * connections - use g_dbus_connection_new() if you need to act as the
2811 * server. In particular, @flags cannot contain the
2812 * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER or
2813 * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS flags.
2815 * When the operation is finished, @callback will be invoked. You can
2816 * then call g_dbus_connection_new_finish() to get the result of the
2819 * If @observer is not %NULL it may be used to control the
2820 * authentication process.
2822 * This is a asynchronous failable constructor. See
2823 * g_dbus_connection_new_for_address_sync() for the synchronous
2829 g_dbus_connection_new_for_address (const gchar
*address
,
2830 GDBusConnectionFlags flags
,
2831 GDBusAuthObserver
*observer
,
2832 GCancellable
*cancellable
,
2833 GAsyncReadyCallback callback
,
2836 _g_dbus_initialize ();
2838 g_return_if_fail (address
!= NULL
);
2840 g_async_initable_new_async (G_TYPE_DBUS_CONNECTION
,
2847 "authentication-observer", observer
,
2852 * g_dbus_connection_new_for_address_finish:
2853 * @res: a #GAsyncResult obtained from the #GAsyncReadyCallback passed
2854 * to g_dbus_connection_new()
2855 * @error: return location for error or %NULL
2857 * Finishes an operation started with g_dbus_connection_new_for_address().
2859 * Returns: a #GDBusConnection or %NULL if @error is set. Free with
2865 g_dbus_connection_new_for_address_finish (GAsyncResult
*res
,
2869 GObject
*source_object
;
2871 g_return_val_if_fail (G_IS_ASYNC_RESULT (res
), NULL
);
2872 g_return_val_if_fail (error
== NULL
|| *error
== NULL
, NULL
);
2874 source_object
= g_async_result_get_source_object (res
);
2875 g_assert (source_object
!= NULL
);
2876 object
= g_async_initable_new_finish (G_ASYNC_INITABLE (source_object
),
2879 g_object_unref (source_object
);
2881 return G_DBUS_CONNECTION (object
);
2887 * g_dbus_connection_new_for_address_sync:
2888 * @address: a D-Bus address
2889 * @flags: flags describing how to make the connection
2890 * @observer: (nullable): a #GDBusAuthObserver or %NULL
2891 * @cancellable: (nullable): a #GCancellable or %NULL
2892 * @error: return location for error or %NULL
2894 * Synchronously connects and sets up a D-Bus client connection for
2895 * exchanging D-Bus messages with an endpoint specified by @address
2896 * which must be in the
2897 * [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
2899 * This constructor can only be used to initiate client-side
2900 * connections - use g_dbus_connection_new_sync() if you need to act
2901 * as the server. In particular, @flags cannot contain the
2902 * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER or
2903 * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS flags.
2905 * This is a synchronous failable constructor. See
2906 * g_dbus_connection_new_for_address() for the asynchronous version.
2908 * If @observer is not %NULL it may be used to control the
2909 * authentication process.
2911 * Returns: a #GDBusConnection or %NULL if @error is set. Free with
2917 g_dbus_connection_new_for_address_sync (const gchar
*address
,
2918 GDBusConnectionFlags flags
,
2919 GDBusAuthObserver
*observer
,
2920 GCancellable
*cancellable
,
2923 _g_dbus_initialize ();
2925 g_return_val_if_fail (address
!= NULL
, NULL
);
2926 g_return_val_if_fail (error
== NULL
|| *error
== NULL
, NULL
);
2927 return g_initable_new (G_TYPE_DBUS_CONNECTION
,
2932 "authentication-observer", observer
,
2936 /* ---------------------------------------------------------------------------------------------------- */
2939 * g_dbus_connection_set_exit_on_close:
2940 * @connection: a #GDBusConnection
2941 * @exit_on_close: whether the process should be terminated
2942 * when @connection is closed by the remote peer
2944 * Sets whether the process should be terminated when @connection is
2945 * closed by the remote peer. See #GDBusConnection:exit-on-close for
2948 * Note that this function should be used with care. Most modern UNIX
2949 * desktops tie the notion of a user session the session bus, and expect
2950 * all of a users applications to quit when their bus connection goes away.
2951 * If you are setting @exit_on_close to %FALSE for the shared session
2952 * bus connection, you should make sure that your application exits
2953 * when the user session ends.
2958 g_dbus_connection_set_exit_on_close (GDBusConnection
*connection
,
2959 gboolean exit_on_close
)
2961 g_return_if_fail (G_IS_DBUS_CONNECTION (connection
));
2964 g_atomic_int_or (&connection
->atomic_flags
, FLAG_EXIT_ON_CLOSE
);
2966 g_atomic_int_and (&connection
->atomic_flags
, ~FLAG_EXIT_ON_CLOSE
);
2971 * g_dbus_connection_get_exit_on_close:
2972 * @connection: a #GDBusConnection
2974 * Gets whether the process is terminated when @connection is
2975 * closed by the remote peer. See
2976 * #GDBusConnection:exit-on-close for more details.
2978 * Returns: whether the process is terminated when @connection is
2979 * closed by the remote peer
2984 g_dbus_connection_get_exit_on_close (GDBusConnection
*connection
)
2986 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), FALSE
);
2988 if (g_atomic_int_get (&connection
->atomic_flags
) & FLAG_EXIT_ON_CLOSE
)
2995 * g_dbus_connection_get_guid:
2996 * @connection: a #GDBusConnection
2998 * The GUID of the peer performing the role of server when
2999 * authenticating. See #GDBusConnection:guid for more details.
3001 * Returns: The GUID. Do not free this string, it is owned by
3007 g_dbus_connection_get_guid (GDBusConnection
*connection
)
3009 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), NULL
);
3010 return connection
->guid
;
3014 * g_dbus_connection_get_unique_name:
3015 * @connection: a #GDBusConnection
3017 * Gets the unique name of @connection as assigned by the message
3018 * bus. This can also be used to figure out if @connection is a
3019 * message bus connection.
3021 * Returns: the unique name or %NULL if @connection is not a message
3022 * bus connection. Do not free this string, it is owned by
3028 g_dbus_connection_get_unique_name (GDBusConnection
*connection
)
3030 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), NULL
);
3032 /* do not use g_return_val_if_fail(), we want the memory barrier */
3033 if (!check_initialized (connection
))
3036 return connection
->bus_unique_name
;
3040 * g_dbus_connection_get_peer_credentials:
3041 * @connection: a #GDBusConnection
3043 * Gets the credentials of the authenticated peer. This will always
3044 * return %NULL unless @connection acted as a server
3045 * (e.g. %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER was passed)
3046 * when set up and the client passed credentials as part of the
3047 * authentication process.
3049 * In a message bus setup, the message bus is always the server and
3050 * each application is a client. So this method will always return
3051 * %NULL for message bus clients.
3053 * Returns: (transfer none) (nullable): a #GCredentials or %NULL if not
3054 * available. Do not free this object, it is owned by @connection.
3059 g_dbus_connection_get_peer_credentials (GDBusConnection
*connection
)
3061 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), NULL
);
3063 /* do not use g_return_val_if_fail(), we want the memory barrier */
3064 if (!check_initialized (connection
))
3067 return connection
->credentials
;
3070 /* ---------------------------------------------------------------------------------------------------- */
3072 static volatile guint _global_filter_id
= 1;
3075 * g_dbus_connection_add_filter:
3076 * @connection: a #GDBusConnection
3077 * @filter_function: a filter function
3078 * @user_data: user data to pass to @filter_function
3079 * @user_data_free_func: function to free @user_data with when filter
3080 * is removed or %NULL
3082 * Adds a message filter. Filters are handlers that are run on all
3083 * incoming and outgoing messages, prior to standard dispatch. Filters
3084 * are run in the order that they were added. The same handler can be
3085 * added as a filter more than once, in which case it will be run more
3086 * than once. Filters added during a filter callback won't be run on
3087 * the message being processed. Filter functions are allowed to modify
3088 * and even drop messages.
3090 * Note that filters are run in a dedicated message handling thread so
3091 * they can't block and, generally, can't do anything but signal a
3092 * worker thread. Also note that filters are rarely needed - use API
3093 * such as g_dbus_connection_send_message_with_reply(),
3094 * g_dbus_connection_signal_subscribe() or g_dbus_connection_call() instead.
3096 * If a filter consumes an incoming message the message is not
3097 * dispatched anywhere else - not even the standard dispatch machinery
3098 * (that API such as g_dbus_connection_signal_subscribe() and
3099 * g_dbus_connection_send_message_with_reply() relies on) will see the
3100 * message. Similary, if a filter consumes an outgoing message, the
3101 * message will not be sent to the other peer.
3103 * If @user_data_free_func is non-%NULL, it will be called (in the
3104 * thread-default main context of the thread you are calling this
3105 * method from) at some point after @user_data is no longer
3106 * needed. (It is not guaranteed to be called synchronously when the
3107 * filter is removed, and may be called after @connection has been
3110 * Returns: a filter identifier that can be used with
3111 * g_dbus_connection_remove_filter()
3116 g_dbus_connection_add_filter (GDBusConnection
*connection
,
3117 GDBusMessageFilterFunction filter_function
,
3119 GDestroyNotify user_data_free_func
)
3123 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), 0);
3124 g_return_val_if_fail (filter_function
!= NULL
, 0);
3125 g_return_val_if_fail (check_initialized (connection
), 0);
3127 CONNECTION_LOCK (connection
);
3128 data
= g_new0 (FilterData
, 1);
3129 data
->id
= g_atomic_int_add (&_global_filter_id
, 1); /* TODO: overflow etc. */
3130 data
->ref_count
= 1;
3131 data
->filter_function
= filter_function
;
3132 data
->user_data
= user_data
;
3133 data
->user_data_free_func
= user_data_free_func
;
3134 data
->context
= g_main_context_ref_thread_default ();
3135 g_ptr_array_add (connection
->filters
, data
);
3136 CONNECTION_UNLOCK (connection
);
3141 /* only called from finalize(), removes all filters */
3143 purge_all_filters (GDBusConnection
*connection
)
3146 for (n
= 0; n
< connection
->filters
->len
; n
++)
3148 FilterData
*data
= connection
->filters
->pdata
[n
];
3150 call_destroy_notify (data
->context
,
3151 data
->user_data_free_func
,
3153 g_main_context_unref (data
->context
);
3159 * g_dbus_connection_remove_filter:
3160 * @connection: a #GDBusConnection
3161 * @filter_id: an identifier obtained from g_dbus_connection_add_filter()
3165 * Note that since filters run in a different thread, there is a race
3166 * condition where it is possible that the filter will be running even
3167 * after calling g_dbus_connection_remove_filter(), so you cannot just
3168 * free data that the filter might be using. Instead, you should pass
3169 * a #GDestroyNotify to g_dbus_connection_add_filter(), which will be
3170 * called when it is guaranteed that the data is no longer needed.
3175 g_dbus_connection_remove_filter (GDBusConnection
*connection
,
3180 FilterData
*to_destroy
;
3182 g_return_if_fail (G_IS_DBUS_CONNECTION (connection
));
3183 g_return_if_fail (check_initialized (connection
));
3185 CONNECTION_LOCK (connection
);
3188 for (n
= 0; n
< connection
->filters
->len
; n
++)
3190 FilterData
*data
= connection
->filters
->pdata
[n
];
3191 if (data
->id
== filter_id
)
3194 g_ptr_array_remove_index (connection
->filters
, n
);
3196 if (data
->ref_count
== 0)
3201 CONNECTION_UNLOCK (connection
);
3203 /* do free without holding lock */
3204 if (to_destroy
!= NULL
)
3206 if (to_destroy
->user_data_free_func
!= NULL
)
3207 to_destroy
->user_data_free_func (to_destroy
->user_data
);
3208 g_main_context_unref (to_destroy
->context
);
3209 g_free (to_destroy
);
3213 g_warning ("g_dbus_connection_remove_filter: No filter found for filter_id %d", filter_id
);
3217 /* ---------------------------------------------------------------------------------------------------- */
3223 gchar
*sender_unique_name
; /* if sender is unique or org.freedesktop.DBus, then that name... otherwise blank */
3224 gchar
*interface_name
;
3228 GDBusSignalFlags flags
;
3229 GArray
*subscribers
;
3234 GDBusSignalCallback callback
;
3236 GDestroyNotify user_data_free_func
;
3238 GMainContext
*context
;
3242 signal_data_free (SignalData
*signal_data
)
3244 g_free (signal_data
->rule
);
3245 g_free (signal_data
->sender
);
3246 g_free (signal_data
->sender_unique_name
);
3247 g_free (signal_data
->interface_name
);
3248 g_free (signal_data
->member
);
3249 g_free (signal_data
->object_path
);
3250 g_free (signal_data
->arg0
);
3251 g_array_free (signal_data
->subscribers
, TRUE
);
3252 g_free (signal_data
);
3256 args_to_rule (const gchar
*sender
,
3257 const gchar
*interface_name
,
3258 const gchar
*member
,
3259 const gchar
*object_path
,
3261 GDBusSignalFlags flags
)
3265 rule
= g_string_new ("type='signal'");
3266 if (flags
& G_DBUS_SIGNAL_FLAGS_NO_MATCH_RULE
)
3267 g_string_prepend_c (rule
, '-');
3269 g_string_append_printf (rule
, ",sender='%s'", sender
);
3270 if (interface_name
!= NULL
)
3271 g_string_append_printf (rule
, ",interface='%s'", interface_name
);
3273 g_string_append_printf (rule
, ",member='%s'", member
);
3274 if (object_path
!= NULL
)
3275 g_string_append_printf (rule
, ",path='%s'", object_path
);
3279 if (flags
& G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH
)
3280 g_string_append_printf (rule
, ",arg0path='%s'", arg0
);
3281 else if (flags
& G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE
)
3282 g_string_append_printf (rule
, ",arg0namespace='%s'", arg0
);
3284 g_string_append_printf (rule
, ",arg0='%s'", arg0
);
3287 return g_string_free (rule
, FALSE
);
3290 static volatile guint _global_subscriber_id
= 1;
3291 static volatile guint _global_registration_id
= 1;
3292 static volatile guint _global_subtree_registration_id
= 1;
3294 /* ---------------------------------------------------------------------------------------------------- */
3296 /* Called in a user thread, lock is held */
3298 add_match_rule (GDBusConnection
*connection
,
3299 const gchar
*match_rule
)
3302 GDBusMessage
*message
;
3304 if (match_rule
[0] == '-')
3307 message
= g_dbus_message_new_method_call ("org.freedesktop.DBus", /* name */
3308 "/org/freedesktop/DBus", /* path */
3309 "org.freedesktop.DBus", /* interface */
3311 g_dbus_message_set_body (message
, g_variant_new ("(s)", match_rule
));
3313 if (!g_dbus_connection_send_message_unlocked (connection
,
3315 G_DBUS_SEND_MESSAGE_FLAGS_NONE
,
3319 g_critical ("Error while sending AddMatch() message: %s", error
->message
);
3320 g_error_free (error
);
3322 g_object_unref (message
);
3325 /* ---------------------------------------------------------------------------------------------------- */
3327 /* Called in a user thread, lock is held */
3329 remove_match_rule (GDBusConnection
*connection
,
3330 const gchar
*match_rule
)
3333 GDBusMessage
*message
;
3335 if (match_rule
[0] == '-')
3338 message
= g_dbus_message_new_method_call ("org.freedesktop.DBus", /* name */
3339 "/org/freedesktop/DBus", /* path */
3340 "org.freedesktop.DBus", /* interface */
3342 g_dbus_message_set_body (message
, g_variant_new ("(s)", match_rule
));
3345 if (!g_dbus_connection_send_message_unlocked (connection
,
3347 G_DBUS_SEND_MESSAGE_FLAGS_NONE
,
3351 /* If we could get G_IO_ERROR_CLOSED here, it wouldn't be reasonable to
3352 * critical; but we're holding the lock, and our caller checked whether
3353 * we were already closed, so we can't get that error.
3355 g_critical ("Error while sending RemoveMatch() message: %s", error
->message
);
3356 g_error_free (error
);
3358 g_object_unref (message
);
3361 /* ---------------------------------------------------------------------------------------------------- */
3364 is_signal_data_for_name_lost_or_acquired (SignalData
*signal_data
)
3366 return g_strcmp0 (signal_data
->sender_unique_name
, "org.freedesktop.DBus") == 0 &&
3367 g_strcmp0 (signal_data
->interface_name
, "org.freedesktop.DBus") == 0 &&
3368 g_strcmp0 (signal_data
->object_path
, "/org/freedesktop/DBus") == 0 &&
3369 (g_strcmp0 (signal_data
->member
, "NameLost") == 0 ||
3370 g_strcmp0 (signal_data
->member
, "NameAcquired") == 0);
3373 /* ---------------------------------------------------------------------------------------------------- */
3376 * g_dbus_connection_signal_subscribe:
3377 * @connection: a #GDBusConnection
3378 * @sender: (nullable): sender name to match on (unique or well-known name)
3379 * or %NULL to listen from all senders
3380 * @interface_name: (nullable): D-Bus interface name to match on or %NULL to
3381 * match on all interfaces
3382 * @member: (nullable): D-Bus signal name to match on or %NULL to match on
3384 * @object_path: (nullable): object path to match on or %NULL to match on
3386 * @arg0: (nullable): contents of first string argument to match on or %NULL
3387 * to match on all kinds of arguments
3388 * @flags: #GDBusSignalFlags describing how arg0 is used in subscribing to the
3390 * @callback: callback to invoke when there is a signal matching the requested data
3391 * @user_data: user data to pass to @callback
3392 * @user_data_free_func: (nullable): function to free @user_data with when
3393 * subscription is removed or %NULL
3395 * Subscribes to signals on @connection and invokes @callback with a whenever
3396 * the signal is received. Note that @callback will be invoked in the
3397 * [thread-default main context][g-main-context-push-thread-default]
3398 * of the thread you are calling this method from.
3400 * If @connection is not a message bus connection, @sender must be
3403 * If @sender is a well-known name note that @callback is invoked with
3404 * the unique name for the owner of @sender, not the well-known name
3405 * as one would expect. This is because the message bus rewrites the
3406 * name. As such, to avoid certain race conditions, users should be
3407 * tracking the name owner of the well-known name and use that when
3408 * processing the received signal.
3410 * If one of %G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE or
3411 * %G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH are given, @arg0 is
3412 * interpreted as part of a namespace or path. The first argument
3413 * of a signal is matched against that part as specified by D-Bus.
3415 * If @user_data_free_func is non-%NULL, it will be called (in the
3416 * thread-default main context of the thread you are calling this
3417 * method from) at some point after @user_data is no longer
3418 * needed. (It is not guaranteed to be called synchronously when the
3419 * signal is unsubscribed from, and may be called after @connection
3420 * has been destroyed.)
3422 * Returns: a subscription identifier that can be used with g_dbus_connection_signal_unsubscribe()
3427 g_dbus_connection_signal_subscribe (GDBusConnection
*connection
,
3428 const gchar
*sender
,
3429 const gchar
*interface_name
,
3430 const gchar
*member
,
3431 const gchar
*object_path
,
3433 GDBusSignalFlags flags
,
3434 GDBusSignalCallback callback
,
3436 GDestroyNotify user_data_free_func
)
3439 SignalData
*signal_data
;
3440 SignalSubscriber subscriber
;
3441 GPtrArray
*signal_data_array
;
3442 const gchar
*sender_unique_name
;
3444 /* Right now we abort if AddMatch() fails since it can only fail with the bus being in
3445 * an OOM condition. We might want to change that but that would involve making
3446 * g_dbus_connection_signal_subscribe() asynchronous and having the call sites
3447 * handle that. And there's really no sensible way of handling this short of retrying
3448 * to add the match rule... and then there's the little thing that, hey, maybe there's
3449 * a reason the bus in an OOM condition.
3451 * Doable, but not really sure it's worth it...
3454 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), 0);
3455 g_return_val_if_fail (sender
== NULL
|| (g_dbus_is_name (sender
) && (connection
->flags
& G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION
)), 0);
3456 g_return_val_if_fail (interface_name
== NULL
|| g_dbus_is_interface_name (interface_name
), 0);
3457 g_return_val_if_fail (member
== NULL
|| g_dbus_is_member_name (member
), 0);
3458 g_return_val_if_fail (object_path
== NULL
|| g_variant_is_object_path (object_path
), 0);
3459 g_return_val_if_fail (callback
!= NULL
, 0);
3460 g_return_val_if_fail (check_initialized (connection
), 0);
3461 g_return_val_if_fail (!((flags
& G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH
) && (flags
& G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE
)), 0);
3462 g_return_val_if_fail (!(arg0
== NULL
&& (flags
& (G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH
| G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE
))), 0);
3464 CONNECTION_LOCK (connection
);
3466 /* If G_DBUS_SIGNAL_FLAGS_NO_MATCH_RULE was specified, we will end up
3467 * with a '-' character to prefix the rule (which will otherwise be
3470 * This allows us to hash the rule and do our lifecycle tracking in
3471 * the usual way, but the '-' prevents the match rule from ever
3472 * actually being send to the bus (either for add or remove).
3474 rule
= args_to_rule (sender
, interface_name
, member
, object_path
, arg0
, flags
);
3476 if (sender
!= NULL
&& (g_dbus_is_unique_name (sender
) || g_strcmp0 (sender
, "org.freedesktop.DBus") == 0))
3477 sender_unique_name
= sender
;
3479 sender_unique_name
= "";
3481 subscriber
.callback
= callback
;
3482 subscriber
.user_data
= user_data
;
3483 subscriber
.user_data_free_func
= user_data_free_func
;
3484 subscriber
.id
= g_atomic_int_add (&_global_subscriber_id
, 1); /* TODO: overflow etc. */
3485 subscriber
.context
= g_main_context_ref_thread_default ();
3487 /* see if we've already have this rule */
3488 signal_data
= g_hash_table_lookup (connection
->map_rule_to_signal_data
, rule
);
3489 if (signal_data
!= NULL
)
3491 g_array_append_val (signal_data
->subscribers
, subscriber
);
3496 signal_data
= g_new0 (SignalData
, 1);
3497 signal_data
->rule
= rule
;
3498 signal_data
->sender
= g_strdup (sender
);
3499 signal_data
->sender_unique_name
= g_strdup (sender_unique_name
);
3500 signal_data
->interface_name
= g_strdup (interface_name
);
3501 signal_data
->member
= g_strdup (member
);
3502 signal_data
->object_path
= g_strdup (object_path
);
3503 signal_data
->arg0
= g_strdup (arg0
);
3504 signal_data
->flags
= flags
;
3505 signal_data
->subscribers
= g_array_new (FALSE
, FALSE
, sizeof (SignalSubscriber
));
3506 g_array_append_val (signal_data
->subscribers
, subscriber
);
3508 g_hash_table_insert (connection
->map_rule_to_signal_data
,
3512 /* Add the match rule to the bus...
3514 * Avoid adding match rules for NameLost and NameAcquired messages - the bus will
3515 * always send such messages to us.
3517 if (connection
->flags
& G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION
)
3519 if (!is_signal_data_for_name_lost_or_acquired (signal_data
))
3520 add_match_rule (connection
, signal_data
->rule
);
3523 signal_data_array
= g_hash_table_lookup (connection
->map_sender_unique_name_to_signal_data_array
,
3524 signal_data
->sender_unique_name
);
3525 if (signal_data_array
== NULL
)
3527 signal_data_array
= g_ptr_array_new ();
3528 g_hash_table_insert (connection
->map_sender_unique_name_to_signal_data_array
,
3529 g_strdup (signal_data
->sender_unique_name
),
3532 g_ptr_array_add (signal_data_array
, signal_data
);
3535 g_hash_table_insert (connection
->map_id_to_signal_data
,
3536 GUINT_TO_POINTER (subscriber
.id
),
3539 CONNECTION_UNLOCK (connection
);
3541 return subscriber
.id
;
3544 /* ---------------------------------------------------------------------------------------------------- */
3546 /* called in any thread */
3547 /* must hold lock when calling this (except if connection->finalizing is TRUE) */
3549 unsubscribe_id_internal (GDBusConnection
*connection
,
3550 guint subscription_id
,
3551 GArray
*out_removed_subscribers
)
3553 SignalData
*signal_data
;
3554 GPtrArray
*signal_data_array
;
3557 signal_data
= g_hash_table_lookup (connection
->map_id_to_signal_data
,
3558 GUINT_TO_POINTER (subscription_id
));
3559 if (signal_data
== NULL
)
3561 /* Don't warn here, we may have thrown all subscriptions out when the connection was closed */
3565 for (n
= 0; n
< signal_data
->subscribers
->len
; n
++)
3567 SignalSubscriber
*subscriber
;
3569 subscriber
= &(g_array_index (signal_data
->subscribers
, SignalSubscriber
, n
));
3570 if (subscriber
->id
!= subscription_id
)
3573 g_warn_if_fail (g_hash_table_remove (connection
->map_id_to_signal_data
,
3574 GUINT_TO_POINTER (subscription_id
)));
3575 g_array_append_val (out_removed_subscribers
, *subscriber
);
3576 g_array_remove_index (signal_data
->subscribers
, n
);
3578 if (signal_data
->subscribers
->len
== 0)
3580 g_warn_if_fail (g_hash_table_remove (connection
->map_rule_to_signal_data
, signal_data
->rule
));
3582 signal_data_array
= g_hash_table_lookup (connection
->map_sender_unique_name_to_signal_data_array
,
3583 signal_data
->sender_unique_name
);
3584 g_warn_if_fail (signal_data_array
!= NULL
);
3585 g_warn_if_fail (g_ptr_array_remove (signal_data_array
, signal_data
));
3587 if (signal_data_array
->len
== 0)
3589 g_warn_if_fail (g_hash_table_remove (connection
->map_sender_unique_name_to_signal_data_array
,
3590 signal_data
->sender_unique_name
));
3593 /* remove the match rule from the bus unless NameLost or NameAcquired (see subscribe()) */
3594 if ((connection
->flags
& G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION
) &&
3595 !is_signal_data_for_name_lost_or_acquired (signal_data
) &&
3596 !g_dbus_connection_is_closed (connection
) &&
3597 !connection
->finalizing
)
3599 /* The check for g_dbus_connection_is_closed() means that
3600 * sending the RemoveMatch message can't fail with
3601 * G_IO_ERROR_CLOSED, because we're holding the lock,
3602 * so on_worker_closed() can't happen between the check we just
3603 * did, and releasing the lock later.
3605 remove_match_rule (connection
, signal_data
->rule
);
3608 signal_data_free (signal_data
);
3614 g_assert_not_reached ();
3621 * g_dbus_connection_signal_unsubscribe:
3622 * @connection: a #GDBusConnection
3623 * @subscription_id: a subscription id obtained from
3624 * g_dbus_connection_signal_subscribe()
3626 * Unsubscribes from signals.
3631 g_dbus_connection_signal_unsubscribe (GDBusConnection
*connection
,
3632 guint subscription_id
)
3634 GArray
*subscribers
;
3637 g_return_if_fail (G_IS_DBUS_CONNECTION (connection
));
3638 g_return_if_fail (check_initialized (connection
));
3640 subscribers
= g_array_new (FALSE
, FALSE
, sizeof (SignalSubscriber
));
3642 CONNECTION_LOCK (connection
);
3643 unsubscribe_id_internal (connection
,
3646 CONNECTION_UNLOCK (connection
);
3649 g_assert (subscribers
->len
== 0 || subscribers
->len
== 1);
3651 /* call GDestroyNotify without lock held */
3652 for (n
= 0; n
< subscribers
->len
; n
++)
3654 SignalSubscriber
*subscriber
;
3655 subscriber
= &(g_array_index (subscribers
, SignalSubscriber
, n
));
3656 call_destroy_notify (subscriber
->context
,
3657 subscriber
->user_data_free_func
,
3658 subscriber
->user_data
);
3659 g_main_context_unref (subscriber
->context
);
3662 g_array_free (subscribers
, TRUE
);
3665 /* ---------------------------------------------------------------------------------------------------- */
3669 guint subscription_id
;
3670 GDBusSignalCallback callback
;
3672 GDBusMessage
*message
;
3673 GDBusConnection
*connection
;
3674 const gchar
*sender
;
3676 const gchar
*interface
;
3677 const gchar
*member
;
3680 /* called on delivery thread (e.g. where g_dbus_connection_signal_subscribe() was called) with
3684 emit_signal_instance_in_idle_cb (gpointer data
)
3686 SignalInstance
*signal_instance
= data
;
3687 GVariant
*parameters
;
3688 gboolean has_subscription
;
3690 parameters
= g_dbus_message_get_body (signal_instance
->message
);
3691 if (parameters
== NULL
)
3693 parameters
= g_variant_new ("()");
3694 g_variant_ref_sink (parameters
);
3698 g_variant_ref_sink (parameters
);
3702 g_print ("in emit_signal_instance_in_idle_cb (id=%d sender=%s path=%s interface=%s member=%s params=%s)\n",
3703 signal_instance
->subscription_id
,
3704 signal_instance
->sender
,
3705 signal_instance
->path
,
3706 signal_instance
->interface
,
3707 signal_instance
->member
,
3708 g_variant_print (parameters
, TRUE
));
3711 /* Careful here, don't do the callback if we no longer has the subscription */
3712 CONNECTION_LOCK (signal_instance
->connection
);
3713 has_subscription
= FALSE
;
3714 if (g_hash_table_lookup (signal_instance
->connection
->map_id_to_signal_data
,
3715 GUINT_TO_POINTER (signal_instance
->subscription_id
)) != NULL
)
3716 has_subscription
= TRUE
;
3717 CONNECTION_UNLOCK (signal_instance
->connection
);
3719 if (has_subscription
)
3720 signal_instance
->callback (signal_instance
->connection
,
3721 signal_instance
->sender
,
3722 signal_instance
->path
,
3723 signal_instance
->interface
,
3724 signal_instance
->member
,
3726 signal_instance
->user_data
);
3728 g_variant_unref (parameters
);
3734 signal_instance_free (SignalInstance
*signal_instance
)
3736 g_object_unref (signal_instance
->message
);
3737 g_object_unref (signal_instance
->connection
);
3738 g_free (signal_instance
);
3742 namespace_rule_matches (const gchar
*namespace,
3748 len_namespace
= strlen (namespace);
3749 len_name
= strlen (name
);
3751 if (len_name
< len_namespace
)
3754 if (memcmp (namespace, name
, len_namespace
) != 0)
3757 return len_namespace
== len_name
|| name
[len_namespace
] == '.';
3761 path_rule_matches (const gchar
*path_a
,
3762 const gchar
*path_b
)
3766 len_a
= strlen (path_a
);
3767 len_b
= strlen (path_b
);
3769 if (len_a
< len_b
&& (len_a
== 0 || path_a
[len_a
- 1] != '/'))
3772 if (len_b
< len_a
&& (len_b
== 0 || path_b
[len_b
- 1] != '/'))
3775 return memcmp (path_a
, path_b
, MIN (len_a
, len_b
)) == 0;
3778 /* called in GDBusWorker thread WITH lock held */
3780 schedule_callbacks (GDBusConnection
*connection
,
3781 GPtrArray
*signal_data_array
,
3782 GDBusMessage
*message
,
3783 const gchar
*sender
)
3786 const gchar
*interface
;
3787 const gchar
*member
;
3796 interface
= g_dbus_message_get_interface (message
);
3797 member
= g_dbus_message_get_member (message
);
3798 path
= g_dbus_message_get_path (message
);
3799 arg0
= g_dbus_message_get_arg0 (message
);
3802 g_print ("In schedule_callbacks:\n"
3804 " interface = '%s'\n"
3815 /* TODO: if this is slow, then we can change signal_data_array into
3816 * map_object_path_to_signal_data_array or something.
3818 for (n
= 0; n
< signal_data_array
->len
; n
++)
3820 SignalData
*signal_data
= signal_data_array
->pdata
[n
];
3822 if (signal_data
->interface_name
!= NULL
&& g_strcmp0 (signal_data
->interface_name
, interface
) != 0)
3825 if (signal_data
->member
!= NULL
&& g_strcmp0 (signal_data
->member
, member
) != 0)
3828 if (signal_data
->object_path
!= NULL
&& g_strcmp0 (signal_data
->object_path
, path
) != 0)
3831 if (signal_data
->arg0
!= NULL
)
3836 if (signal_data
->flags
& G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE
)
3838 if (!namespace_rule_matches (signal_data
->arg0
, arg0
))
3841 else if (signal_data
->flags
& G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH
)
3843 if (!path_rule_matches (signal_data
->arg0
, arg0
))
3846 else if (!g_str_equal (signal_data
->arg0
, arg0
))
3850 for (m
= 0; m
< signal_data
->subscribers
->len
; m
++)
3852 SignalSubscriber
*subscriber
;
3853 GSource
*idle_source
;
3854 SignalInstance
*signal_instance
;
3856 subscriber
= &(g_array_index (signal_data
->subscribers
, SignalSubscriber
, m
));
3858 signal_instance
= g_new0 (SignalInstance
, 1);
3859 signal_instance
->subscription_id
= subscriber
->id
;
3860 signal_instance
->callback
= subscriber
->callback
;
3861 signal_instance
->user_data
= subscriber
->user_data
;
3862 signal_instance
->message
= g_object_ref (message
);
3863 signal_instance
->connection
= g_object_ref (connection
);
3864 signal_instance
->sender
= sender
;
3865 signal_instance
->path
= path
;
3866 signal_instance
->interface
= interface
;
3867 signal_instance
->member
= member
;
3869 idle_source
= g_idle_source_new ();
3870 g_source_set_priority (idle_source
, G_PRIORITY_DEFAULT
);
3871 g_source_set_callback (idle_source
,
3872 emit_signal_instance_in_idle_cb
,
3874 (GDestroyNotify
) signal_instance_free
);
3875 g_source_set_name (idle_source
, "[gio] emit_signal_instance_in_idle_cb");
3876 g_source_attach (idle_source
, subscriber
->context
);
3877 g_source_unref (idle_source
);
3882 /* called in GDBusWorker thread with lock held */
3884 distribute_signals (GDBusConnection
*connection
,
3885 GDBusMessage
*message
)
3887 GPtrArray
*signal_data_array
;
3888 const gchar
*sender
;
3890 sender
= g_dbus_message_get_sender (message
);
3892 if (G_UNLIKELY (_g_dbus_debug_signal ()))
3894 _g_dbus_debug_print_lock ();
3895 g_print ("========================================================================\n"
3896 "GDBus-debug:Signal:\n"
3897 " <<<< RECEIVED SIGNAL %s.%s\n"
3899 " sent by name %s\n",
3900 g_dbus_message_get_interface (message
),
3901 g_dbus_message_get_member (message
),
3902 g_dbus_message_get_path (message
),
3903 sender
!= NULL
? sender
: "(none)");
3904 _g_dbus_debug_print_unlock ();
3907 /* collect subscribers that match on sender */
3910 signal_data_array
= g_hash_table_lookup (connection
->map_sender_unique_name_to_signal_data_array
, sender
);
3911 if (signal_data_array
!= NULL
)
3912 schedule_callbacks (connection
, signal_data_array
, message
, sender
);
3915 /* collect subscribers not matching on sender */
3916 signal_data_array
= g_hash_table_lookup (connection
->map_sender_unique_name_to_signal_data_array
, "");
3917 if (signal_data_array
!= NULL
)
3918 schedule_callbacks (connection
, signal_data_array
, message
, sender
);
3921 /* ---------------------------------------------------------------------------------------------------- */
3923 /* only called from finalize(), removes all subscriptions */
3925 purge_all_signal_subscriptions (GDBusConnection
*connection
)
3927 GHashTableIter iter
;
3930 GArray
*subscribers
;
3933 ids
= g_array_new (FALSE
, FALSE
, sizeof (guint
));
3934 g_hash_table_iter_init (&iter
, connection
->map_id_to_signal_data
);
3935 while (g_hash_table_iter_next (&iter
, &key
, NULL
))
3937 guint subscription_id
= GPOINTER_TO_UINT (key
);
3938 g_array_append_val (ids
, subscription_id
);
3941 subscribers
= g_array_new (FALSE
, FALSE
, sizeof (SignalSubscriber
));
3942 for (n
= 0; n
< ids
->len
; n
++)
3944 guint subscription_id
= g_array_index (ids
, guint
, n
);
3945 unsubscribe_id_internal (connection
,
3949 g_array_free (ids
, TRUE
);
3951 /* call GDestroyNotify without lock held */
3952 for (n
= 0; n
< subscribers
->len
; n
++)
3954 SignalSubscriber
*subscriber
;
3955 subscriber
= &(g_array_index (subscribers
, SignalSubscriber
, n
));
3956 call_destroy_notify (subscriber
->context
,
3957 subscriber
->user_data_free_func
,
3958 subscriber
->user_data
);
3959 g_main_context_unref (subscriber
->context
);
3962 g_array_free (subscribers
, TRUE
);
3965 /* ---------------------------------------------------------------------------------------------------- */
3967 static GDBusInterfaceVTable
*
3968 _g_dbus_interface_vtable_copy (const GDBusInterfaceVTable
*vtable
)
3970 /* Don't waste memory by copying padding - remember to update this
3971 * when changing struct _GDBusInterfaceVTable in gdbusconnection.h
3973 return g_memdup ((gconstpointer
) vtable
, 3 * sizeof (gpointer
));
3977 _g_dbus_interface_vtable_free (GDBusInterfaceVTable
*vtable
)
3982 /* ---------------------------------------------------------------------------------------------------- */
3984 static GDBusSubtreeVTable
*
3985 _g_dbus_subtree_vtable_copy (const GDBusSubtreeVTable
*vtable
)
3987 /* Don't waste memory by copying padding - remember to update this
3988 * when changing struct _GDBusSubtreeVTable in gdbusconnection.h
3990 return g_memdup ((gconstpointer
) vtable
, 3 * sizeof (gpointer
));
3994 _g_dbus_subtree_vtable_free (GDBusSubtreeVTable
*vtable
)
3999 /* ---------------------------------------------------------------------------------------------------- */
4001 struct ExportedObject
4004 GDBusConnection
*connection
;
4006 /* maps gchar* -> ExportedInterface* */
4007 GHashTable
*map_if_name_to_ei
;
4010 /* only called with lock held */
4012 exported_object_free (ExportedObject
*eo
)
4014 g_free (eo
->object_path
);
4015 g_hash_table_unref (eo
->map_if_name_to_ei
);
4024 gchar
*interface_name
;
4025 GDBusInterfaceVTable
*vtable
;
4026 GDBusInterfaceInfo
*interface_info
;
4028 GMainContext
*context
;
4030 GDestroyNotify user_data_free_func
;
4031 } ExportedInterface
;
4033 /* called with lock held */
4035 exported_interface_free (ExportedInterface
*ei
)
4037 g_dbus_interface_info_cache_release (ei
->interface_info
);
4038 g_dbus_interface_info_unref ((GDBusInterfaceInfo
*) ei
->interface_info
);
4040 call_destroy_notify (ei
->context
,
4041 ei
->user_data_free_func
,
4044 g_main_context_unref (ei
->context
);
4046 g_free (ei
->interface_name
);
4047 _g_dbus_interface_vtable_free (ei
->vtable
);
4051 /* ---------------------------------------------------------------------------------------------------- */
4053 /* Convenience function to check if @registration_id (if not zero) or
4054 * @subtree_registration_id (if not zero) has been unregistered. If
4055 * so, returns %TRUE.
4057 * May be called by any thread. Caller must *not* hold lock.
4060 has_object_been_unregistered (GDBusConnection
*connection
,
4061 guint registration_id
,
4062 guint subtree_registration_id
)
4066 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), FALSE
);
4070 CONNECTION_LOCK (connection
);
4071 if (registration_id
!= 0 && g_hash_table_lookup (connection
->map_id_to_ei
,
4072 GUINT_TO_POINTER (registration_id
)) == NULL
)
4076 else if (subtree_registration_id
!= 0 && g_hash_table_lookup (connection
->map_id_to_es
,
4077 GUINT_TO_POINTER (subtree_registration_id
)) == NULL
)
4081 CONNECTION_UNLOCK (connection
);
4086 /* ---------------------------------------------------------------------------------------------------- */
4090 GDBusConnection
*connection
;
4091 GDBusMessage
*message
;
4093 const gchar
*property_name
;
4094 const GDBusInterfaceVTable
*vtable
;
4095 GDBusInterfaceInfo
*interface_info
;
4096 const GDBusPropertyInfo
*property_info
;
4097 guint registration_id
;
4098 guint subtree_registration_id
;
4102 property_data_free (PropertyData
*data
)
4104 g_object_unref (data
->connection
);
4105 g_object_unref (data
->message
);
4109 /* called in thread where object was registered - no locks held */
4111 invoke_get_property_in_idle_cb (gpointer _data
)
4113 PropertyData
*data
= _data
;
4116 GDBusMessage
*reply
;
4118 if (has_object_been_unregistered (data
->connection
,
4119 data
->registration_id
,
4120 data
->subtree_registration_id
))
4122 reply
= g_dbus_message_new_method_error (data
->message
,
4123 "org.freedesktop.DBus.Error.UnknownMethod",
4124 _("No such interface 'org.freedesktop.DBus.Properties' on object at path %s"),
4125 g_dbus_message_get_path (data
->message
));
4126 g_dbus_connection_send_message (data
->connection
, reply
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, NULL
);
4127 g_object_unref (reply
);
4132 value
= data
->vtable
->get_property (data
->connection
,
4133 g_dbus_message_get_sender (data
->message
),
4134 g_dbus_message_get_path (data
->message
),
4135 data
->interface_info
->name
,
4136 data
->property_name
,
4143 g_assert_no_error (error
);
4145 g_variant_take_ref (value
);
4146 reply
= g_dbus_message_new_method_reply (data
->message
);
4147 g_dbus_message_set_body (reply
, g_variant_new ("(v)", value
));
4148 g_dbus_connection_send_message (data
->connection
, reply
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, NULL
);
4149 g_variant_unref (value
);
4150 g_object_unref (reply
);
4154 gchar
*dbus_error_name
;
4155 g_assert (error
!= NULL
);
4156 dbus_error_name
= g_dbus_error_encode_gerror (error
);
4157 reply
= g_dbus_message_new_method_error_literal (data
->message
,
4160 g_dbus_connection_send_message (data
->connection
, reply
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, NULL
);
4161 g_free (dbus_error_name
);
4162 g_error_free (error
);
4163 g_object_unref (reply
);
4170 /* called in thread where object was registered - no locks held */
4172 invoke_set_property_in_idle_cb (gpointer _data
)
4174 PropertyData
*data
= _data
;
4176 GDBusMessage
*reply
;
4182 g_variant_get (g_dbus_message_get_body (data
->message
),
4188 if (!data
->vtable
->set_property (data
->connection
,
4189 g_dbus_message_get_sender (data
->message
),
4190 g_dbus_message_get_path (data
->message
),
4191 data
->interface_info
->name
,
4192 data
->property_name
,
4197 gchar
*dbus_error_name
;
4198 g_assert (error
!= NULL
);
4199 dbus_error_name
= g_dbus_error_encode_gerror (error
);
4200 reply
= g_dbus_message_new_method_error_literal (data
->message
,
4203 g_free (dbus_error_name
);
4204 g_error_free (error
);
4208 reply
= g_dbus_message_new_method_reply (data
->message
);
4211 g_assert (reply
!= NULL
);
4212 g_dbus_connection_send_message (data
->connection
, reply
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, NULL
);
4213 g_object_unref (reply
);
4214 g_variant_unref (value
);
4219 /* called in any thread with connection's lock held */
4221 validate_and_maybe_schedule_property_getset (GDBusConnection
*connection
,
4222 GDBusMessage
*message
,
4223 guint registration_id
,
4224 guint subtree_registration_id
,
4226 GDBusInterfaceInfo
*interface_info
,
4227 const GDBusInterfaceVTable
*vtable
,
4228 GMainContext
*main_context
,
4232 const char *interface_name
;
4233 const char *property_name
;
4234 const GDBusPropertyInfo
*property_info
;
4235 GSource
*idle_source
;
4236 PropertyData
*property_data
;
4237 GDBusMessage
*reply
;
4242 g_variant_get (g_dbus_message_get_body (message
),
4247 g_variant_get (g_dbus_message_get_body (message
),
4256 /* Check that the property exists - if not fail with org.freedesktop.DBus.Error.InvalidArgs
4258 property_info
= NULL
;
4260 /* TODO: the cost of this is O(n) - it might be worth caching the result */
4261 property_info
= g_dbus_interface_info_lookup_property (interface_info
, property_name
);
4262 if (property_info
== NULL
)
4264 reply
= g_dbus_message_new_method_error (message
,
4265 "org.freedesktop.DBus.Error.InvalidArgs",
4266 _("No such property '%s'"),
4268 g_dbus_connection_send_message_unlocked (connection
, reply
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, NULL
);
4269 g_object_unref (reply
);
4274 if (is_get
&& !(property_info
->flags
& G_DBUS_PROPERTY_INFO_FLAGS_READABLE
))
4276 reply
= g_dbus_message_new_method_error (message
,
4277 "org.freedesktop.DBus.Error.InvalidArgs",
4278 _("Property '%s' is not readable"),
4280 g_dbus_connection_send_message_unlocked (connection
, reply
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, NULL
);
4281 g_object_unref (reply
);
4285 else if (!is_get
&& !(property_info
->flags
& G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE
))
4287 reply
= g_dbus_message_new_method_error (message
,
4288 "org.freedesktop.DBus.Error.InvalidArgs",
4289 _("Property '%s' is not writable"),
4291 g_dbus_connection_send_message_unlocked (connection
, reply
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, NULL
);
4292 g_object_unref (reply
);
4301 /* Fail with org.freedesktop.DBus.Error.InvalidArgs if the type
4302 * of the given value is wrong
4304 g_variant_get_child (g_dbus_message_get_body (message
), 2, "v", &value
);
4305 if (g_strcmp0 (g_variant_get_type_string (value
), property_info
->signature
) != 0)
4307 reply
= g_dbus_message_new_method_error (message
,
4308 "org.freedesktop.DBus.Error.InvalidArgs",
4309 _("Error setting property '%s': Expected type '%s' but got '%s'"),
4310 property_name
, property_info
->signature
,
4311 g_variant_get_type_string (value
));
4312 g_dbus_connection_send_message_unlocked (connection
, reply
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, NULL
);
4313 g_variant_unref (value
);
4314 g_object_unref (reply
);
4319 g_variant_unref (value
);
4322 /* If the vtable pointer for get_property() resp. set_property() is
4323 * NULL then dispatch the call via the method_call() handler.
4327 if (vtable
->get_property
== NULL
)
4329 schedule_method_call (connection
, message
, registration_id
, subtree_registration_id
,
4330 interface_info
, NULL
, property_info
, g_dbus_message_get_body (message
),
4331 vtable
, main_context
, user_data
);
4338 if (vtable
->set_property
== NULL
)
4340 schedule_method_call (connection
, message
, registration_id
, subtree_registration_id
,
4341 interface_info
, NULL
, property_info
, g_dbus_message_get_body (message
),
4342 vtable
, main_context
, user_data
);
4348 /* ok, got the property info - call user code in an idle handler */
4349 property_data
= g_new0 (PropertyData
, 1);
4350 property_data
->connection
= g_object_ref (connection
);
4351 property_data
->message
= g_object_ref (message
);
4352 property_data
->user_data
= user_data
;
4353 property_data
->property_name
= property_name
;
4354 property_data
->vtable
= vtable
;
4355 property_data
->interface_info
= interface_info
;
4356 property_data
->property_info
= property_info
;
4357 property_data
->registration_id
= registration_id
;
4358 property_data
->subtree_registration_id
= subtree_registration_id
;
4360 idle_source
= g_idle_source_new ();
4361 g_source_set_priority (idle_source
, G_PRIORITY_DEFAULT
);
4362 g_source_set_callback (idle_source
,
4363 is_get
? invoke_get_property_in_idle_cb
: invoke_set_property_in_idle_cb
,
4365 (GDestroyNotify
) property_data_free
);
4367 g_source_set_name (idle_source
, "[gio] invoke_get_property_in_idle_cb");
4369 g_source_set_name (idle_source
, "[gio] invoke_set_property_in_idle_cb");
4370 g_source_attach (idle_source
, main_context
);
4371 g_source_unref (idle_source
);
4379 /* called in GDBusWorker thread with connection's lock held */
4381 handle_getset_property (GDBusConnection
*connection
,
4383 GDBusMessage
*message
,
4386 ExportedInterface
*ei
;
4388 const char *interface_name
;
4389 const char *property_name
;
4394 g_variant_get (g_dbus_message_get_body (message
),
4399 g_variant_get (g_dbus_message_get_body (message
),
4405 /* Fail with org.freedesktop.DBus.Error.InvalidArgs if there is
4406 * no such interface registered
4408 ei
= g_hash_table_lookup (eo
->map_if_name_to_ei
, interface_name
);
4411 GDBusMessage
*reply
;
4412 reply
= g_dbus_message_new_method_error (message
,
4413 "org.freedesktop.DBus.Error.InvalidArgs",
4414 _("No such interface '%s'"),
4416 g_dbus_connection_send_message_unlocked (eo
->connection
, reply
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, NULL
);
4417 g_object_unref (reply
);
4422 handled
= validate_and_maybe_schedule_property_getset (eo
->connection
,
4435 /* ---------------------------------------------------------------------------------------------------- */
4439 GDBusConnection
*connection
;
4440 GDBusMessage
*message
;
4442 const GDBusInterfaceVTable
*vtable
;
4443 GDBusInterfaceInfo
*interface_info
;
4444 guint registration_id
;
4445 guint subtree_registration_id
;
4446 } PropertyGetAllData
;
4449 property_get_all_data_free (PropertyData
*data
)
4451 g_object_unref (data
->connection
);
4452 g_object_unref (data
->message
);
4456 /* called in thread where object was registered - no locks held */
4458 invoke_get_all_properties_in_idle_cb (gpointer _data
)
4460 PropertyGetAllData
*data
= _data
;
4461 GVariantBuilder builder
;
4462 GDBusMessage
*reply
;
4465 if (has_object_been_unregistered (data
->connection
,
4466 data
->registration_id
,
4467 data
->subtree_registration_id
))
4469 reply
= g_dbus_message_new_method_error (data
->message
,
4470 "org.freedesktop.DBus.Error.UnknownMethod",
4471 _("No such interface 'org.freedesktop.DBus.Properties' on object at path %s"),
4472 g_dbus_message_get_path (data
->message
));
4473 g_dbus_connection_send_message (data
->connection
, reply
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, NULL
);
4474 g_object_unref (reply
);
4478 /* TODO: Right now we never fail this call - we just omit values if
4479 * a get_property() call is failing.
4481 * We could fail the whole call if just a single get_property() call
4482 * returns an error. We need clarification in the D-Bus spec about this.
4484 g_variant_builder_init (&builder
, G_VARIANT_TYPE ("(a{sv})"));
4485 g_variant_builder_open (&builder
, G_VARIANT_TYPE ("a{sv}"));
4486 for (n
= 0; data
->interface_info
->properties
!= NULL
&& data
->interface_info
->properties
[n
] != NULL
; n
++)
4488 const GDBusPropertyInfo
*property_info
= data
->interface_info
->properties
[n
];
4491 if (!(property_info
->flags
& G_DBUS_PROPERTY_INFO_FLAGS_READABLE
))
4494 value
= data
->vtable
->get_property (data
->connection
,
4495 g_dbus_message_get_sender (data
->message
),
4496 g_dbus_message_get_path (data
->message
),
4497 data
->interface_info
->name
,
4498 property_info
->name
,
4505 g_variant_take_ref (value
);
4506 g_variant_builder_add (&builder
,
4508 property_info
->name
,
4510 g_variant_unref (value
);
4512 g_variant_builder_close (&builder
);
4514 reply
= g_dbus_message_new_method_reply (data
->message
);
4515 g_dbus_message_set_body (reply
, g_variant_builder_end (&builder
));
4516 g_dbus_connection_send_message (data
->connection
, reply
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, NULL
);
4517 g_object_unref (reply
);
4524 interface_has_readable_properties (GDBusInterfaceInfo
*interface_info
)
4528 if (!interface_info
->properties
)
4531 for (i
= 0; interface_info
->properties
[i
]; i
++)
4532 if (interface_info
->properties
[i
]->flags
& G_DBUS_PROPERTY_INFO_FLAGS_READABLE
)
4538 /* called in any thread with connection's lock held */
4540 validate_and_maybe_schedule_property_get_all (GDBusConnection
*connection
,
4541 GDBusMessage
*message
,
4542 guint registration_id
,
4543 guint subtree_registration_id
,
4544 GDBusInterfaceInfo
*interface_info
,
4545 const GDBusInterfaceVTable
*vtable
,
4546 GMainContext
*main_context
,
4550 GSource
*idle_source
;
4551 PropertyGetAllData
*property_get_all_data
;
4558 /* If the vtable pointer for get_property() is NULL but we have a
4559 * non-zero number of readable properties, then dispatch the call via
4560 * the method_call() handler.
4562 if (vtable
->get_property
== NULL
&& interface_has_readable_properties (interface_info
))
4564 schedule_method_call (connection
, message
, registration_id
, subtree_registration_id
,
4565 interface_info
, NULL
, NULL
, g_dbus_message_get_body (message
),
4566 vtable
, main_context
, user_data
);
4571 /* ok, got the property info - call user in an idle handler */
4572 property_get_all_data
= g_new0 (PropertyGetAllData
, 1);
4573 property_get_all_data
->connection
= g_object_ref (connection
);
4574 property_get_all_data
->message
= g_object_ref (message
);
4575 property_get_all_data
->user_data
= user_data
;
4576 property_get_all_data
->vtable
= vtable
;
4577 property_get_all_data
->interface_info
= interface_info
;
4578 property_get_all_data
->registration_id
= registration_id
;
4579 property_get_all_data
->subtree_registration_id
= subtree_registration_id
;
4581 idle_source
= g_idle_source_new ();
4582 g_source_set_priority (idle_source
, G_PRIORITY_DEFAULT
);
4583 g_source_set_callback (idle_source
,
4584 invoke_get_all_properties_in_idle_cb
,
4585 property_get_all_data
,
4586 (GDestroyNotify
) property_get_all_data_free
);
4587 g_source_set_name (idle_source
, "[gio] invoke_get_all_properties_in_idle_cb");
4588 g_source_attach (idle_source
, main_context
);
4589 g_source_unref (idle_source
);
4597 /* called in GDBusWorker thread with connection's lock held */
4599 handle_get_all_properties (GDBusConnection
*connection
,
4601 GDBusMessage
*message
)
4603 ExportedInterface
*ei
;
4605 const char *interface_name
;
4609 g_variant_get (g_dbus_message_get_body (message
),
4613 /* Fail with org.freedesktop.DBus.Error.InvalidArgs if there is
4614 * no such interface registered
4616 ei
= g_hash_table_lookup (eo
->map_if_name_to_ei
, interface_name
);
4619 GDBusMessage
*reply
;
4620 reply
= g_dbus_message_new_method_error (message
,
4621 "org.freedesktop.DBus.Error.InvalidArgs",
4622 _("No such interface '%s'"),
4624 g_dbus_connection_send_message_unlocked (eo
->connection
, reply
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, NULL
);
4625 g_object_unref (reply
);
4630 handled
= validate_and_maybe_schedule_property_get_all (eo
->connection
,
4642 /* ---------------------------------------------------------------------------------------------------- */
4644 static const gchar introspect_header
[] =
4645 "<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\"\n"
4646 " \"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n"
4647 "<!-- GDBus " PACKAGE_VERSION
" -->\n"
4650 static const gchar introspect_tail
[] =
4653 static const gchar introspect_properties_interface
[] =
4654 " <interface name=\"org.freedesktop.DBus.Properties\">\n"
4655 " <method name=\"Get\">\n"
4656 " <arg type=\"s\" name=\"interface_name\" direction=\"in\"/>\n"
4657 " <arg type=\"s\" name=\"property_name\" direction=\"in\"/>\n"
4658 " <arg type=\"v\" name=\"value\" direction=\"out\"/>\n"
4660 " <method name=\"GetAll\">\n"
4661 " <arg type=\"s\" name=\"interface_name\" direction=\"in\"/>\n"
4662 " <arg type=\"a{sv}\" name=\"properties\" direction=\"out\"/>\n"
4664 " <method name=\"Set\">\n"
4665 " <arg type=\"s\" name=\"interface_name\" direction=\"in\"/>\n"
4666 " <arg type=\"s\" name=\"property_name\" direction=\"in\"/>\n"
4667 " <arg type=\"v\" name=\"value\" direction=\"in\"/>\n"
4669 " <signal name=\"PropertiesChanged\">\n"
4670 " <arg type=\"s\" name=\"interface_name\"/>\n"
4671 " <arg type=\"a{sv}\" name=\"changed_properties\"/>\n"
4672 " <arg type=\"as\" name=\"invalidated_properties\"/>\n"
4676 static const gchar introspect_introspectable_interface
[] =
4677 " <interface name=\"org.freedesktop.DBus.Introspectable\">\n"
4678 " <method name=\"Introspect\">\n"
4679 " <arg type=\"s\" name=\"xml_data\" direction=\"out\"/>\n"
4682 " <interface name=\"org.freedesktop.DBus.Peer\">\n"
4683 " <method name=\"Ping\"/>\n"
4684 " <method name=\"GetMachineId\">\n"
4685 " <arg type=\"s\" name=\"machine_uuid\" direction=\"out\"/>\n"
4690 introspect_append_header (GString
*s
)
4692 g_string_append (s
, introspect_header
);
4696 maybe_add_path (const gchar
*path
, gsize path_len
, const gchar
*object_path
, GHashTable
*set
)
4698 if (g_str_has_prefix (object_path
, path
) && strlen (object_path
) > path_len
&& object_path
[path_len
-1] == '/')
4704 begin
= object_path
+ path_len
;
4705 end
= strchr (begin
, '/');
4707 s
= g_strndup (begin
, end
- begin
);
4709 s
= g_strdup (begin
);
4711 if (g_hash_table_lookup (set
, s
) == NULL
)
4712 g_hash_table_insert (set
, s
, GUINT_TO_POINTER (1));
4718 /* TODO: we want a nicer public interface for this */
4719 /* called in any thread with connection's lock held */
4721 g_dbus_connection_list_registered_unlocked (GDBusConnection
*connection
,
4726 GHashTableIter hash_iter
;
4727 const gchar
*object_path
;
4733 CONNECTION_ENSURE_LOCK (connection
);
4735 path_len
= strlen (path
);
4739 set
= g_hash_table_new (g_str_hash
, g_str_equal
);
4741 g_hash_table_iter_init (&hash_iter
, connection
->map_object_path_to_eo
);
4742 while (g_hash_table_iter_next (&hash_iter
, (gpointer
) &object_path
, NULL
))
4743 maybe_add_path (path
, path_len
, object_path
, set
);
4745 g_hash_table_iter_init (&hash_iter
, connection
->map_object_path_to_es
);
4746 while (g_hash_table_iter_next (&hash_iter
, (gpointer
) &object_path
, NULL
))
4747 maybe_add_path (path
, path_len
, object_path
, set
);
4749 p
= g_ptr_array_new ();
4750 keys
= g_hash_table_get_keys (set
);
4751 for (l
= keys
; l
!= NULL
; l
= l
->next
)
4752 g_ptr_array_add (p
, l
->data
);
4753 g_hash_table_unref (set
);
4756 g_ptr_array_add (p
, NULL
);
4757 ret
= (gchar
**) g_ptr_array_free (p
, FALSE
);
4761 /* called in any thread with connection's lock not held */
4763 g_dbus_connection_list_registered (GDBusConnection
*connection
,
4767 CONNECTION_LOCK (connection
);
4768 ret
= g_dbus_connection_list_registered_unlocked (connection
, path
);
4769 CONNECTION_UNLOCK (connection
);
4773 /* called in GDBusWorker thread with connection's lock held */
4775 handle_introspect (GDBusConnection
*connection
,
4777 GDBusMessage
*message
)
4781 GDBusMessage
*reply
;
4782 GHashTableIter hash_iter
;
4783 ExportedInterface
*ei
;
4786 /* first the header with the standard interfaces */
4787 s
= g_string_sized_new (sizeof (introspect_header
) +
4788 sizeof (introspect_properties_interface
) +
4789 sizeof (introspect_introspectable_interface
) +
4790 sizeof (introspect_tail
));
4791 introspect_append_header (s
);
4792 if (!g_hash_table_lookup (eo
->map_if_name_to_ei
,
4793 "org.freedesktop.DBus.Properties"))
4794 g_string_append (s
, introspect_properties_interface
);
4796 if (!g_hash_table_lookup (eo
->map_if_name_to_ei
,
4797 "org.freedesktop.DBus.Introspectable"))
4798 g_string_append (s
, introspect_introspectable_interface
);
4800 /* then include the registered interfaces */
4801 g_hash_table_iter_init (&hash_iter
, eo
->map_if_name_to_ei
);
4802 while (g_hash_table_iter_next (&hash_iter
, NULL
, (gpointer
) &ei
))
4803 g_dbus_interface_info_generate_xml (ei
->interface_info
, 2, s
);
4805 /* finally include nodes registered below us */
4806 registered
= g_dbus_connection_list_registered_unlocked (connection
, eo
->object_path
);
4807 for (n
= 0; registered
!= NULL
&& registered
[n
] != NULL
; n
++)
4808 g_string_append_printf (s
, " <node name=\"%s\"/>\n", registered
[n
]);
4809 g_strfreev (registered
);
4810 g_string_append (s
, introspect_tail
);
4812 reply
= g_dbus_message_new_method_reply (message
);
4813 g_dbus_message_set_body (reply
, g_variant_new ("(s)", s
->str
));
4814 g_dbus_connection_send_message_unlocked (connection
, reply
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, NULL
);
4815 g_object_unref (reply
);
4816 g_string_free (s
, TRUE
);
4821 /* called in thread where object was registered - no locks held */
4823 call_in_idle_cb (gpointer user_data
)
4825 GDBusMethodInvocation
*invocation
= G_DBUS_METHOD_INVOCATION (user_data
);
4826 GDBusInterfaceVTable
*vtable
;
4827 guint registration_id
;
4828 guint subtree_registration_id
;
4830 registration_id
= GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (invocation
), "g-dbus-registration-id"));
4831 subtree_registration_id
= GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (invocation
), "g-dbus-subtree-registration-id"));
4833 if (has_object_been_unregistered (g_dbus_method_invocation_get_connection (invocation
),
4835 subtree_registration_id
))
4837 GDBusMessage
*reply
;
4838 reply
= g_dbus_message_new_method_error (g_dbus_method_invocation_get_message (invocation
),
4839 "org.freedesktop.DBus.Error.UnknownMethod",
4840 _("No such interface '%s' on object at path %s"),
4841 g_dbus_method_invocation_get_interface_name (invocation
),
4842 g_dbus_method_invocation_get_object_path (invocation
));
4843 g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation
), reply
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, NULL
);
4844 g_object_unref (reply
);
4848 vtable
= g_object_get_data (G_OBJECT (invocation
), "g-dbus-interface-vtable");
4849 g_assert (vtable
!= NULL
&& vtable
->method_call
!= NULL
);
4851 vtable
->method_call (g_dbus_method_invocation_get_connection (invocation
),
4852 g_dbus_method_invocation_get_sender (invocation
),
4853 g_dbus_method_invocation_get_object_path (invocation
),
4854 g_dbus_method_invocation_get_interface_name (invocation
),
4855 g_dbus_method_invocation_get_method_name (invocation
),
4856 g_dbus_method_invocation_get_parameters (invocation
),
4857 g_object_ref (invocation
),
4858 g_dbus_method_invocation_get_user_data (invocation
));
4864 /* called in GDBusWorker thread with connection's lock held */
4866 schedule_method_call (GDBusConnection
*connection
,
4867 GDBusMessage
*message
,
4868 guint registration_id
,
4869 guint subtree_registration_id
,
4870 const GDBusInterfaceInfo
*interface_info
,
4871 const GDBusMethodInfo
*method_info
,
4872 const GDBusPropertyInfo
*property_info
,
4873 GVariant
*parameters
,
4874 const GDBusInterfaceVTable
*vtable
,
4875 GMainContext
*main_context
,
4878 GDBusMethodInvocation
*invocation
;
4879 GSource
*idle_source
;
4881 invocation
= _g_dbus_method_invocation_new (g_dbus_message_get_sender (message
),
4882 g_dbus_message_get_path (message
),
4883 g_dbus_message_get_interface (message
),
4884 g_dbus_message_get_member (message
),
4892 /* TODO: would be nicer with a real MethodData like we already
4893 * have PropertyData and PropertyGetAllData... */
4894 g_object_set_data (G_OBJECT (invocation
), "g-dbus-interface-vtable", (gpointer
) vtable
);
4895 g_object_set_data (G_OBJECT (invocation
), "g-dbus-registration-id", GUINT_TO_POINTER (registration_id
));
4896 g_object_set_data (G_OBJECT (invocation
), "g-dbus-subtree-registration-id", GUINT_TO_POINTER (subtree_registration_id
));
4898 idle_source
= g_idle_source_new ();
4899 g_source_set_priority (idle_source
, G_PRIORITY_DEFAULT
);
4900 g_source_set_callback (idle_source
,
4904 g_source_set_name (idle_source
, "[gio, " __FILE__
"] call_in_idle_cb");
4905 g_source_attach (idle_source
, main_context
);
4906 g_source_unref (idle_source
);
4909 /* called in GDBusWorker thread with connection's lock held */
4911 validate_and_maybe_schedule_method_call (GDBusConnection
*connection
,
4912 GDBusMessage
*message
,
4913 guint registration_id
,
4914 guint subtree_registration_id
,
4915 GDBusInterfaceInfo
*interface_info
,
4916 const GDBusInterfaceVTable
*vtable
,
4917 GMainContext
*main_context
,
4920 GDBusMethodInfo
*method_info
;
4921 GDBusMessage
*reply
;
4922 GVariant
*parameters
;
4924 GVariantType
*in_type
;
4928 /* TODO: the cost of this is O(n) - it might be worth caching the result */
4929 method_info
= g_dbus_interface_info_lookup_method (interface_info
, g_dbus_message_get_member (message
));
4931 /* if the method doesn't exist, return the org.freedesktop.DBus.Error.UnknownMethod
4932 * error to the caller
4934 if (method_info
== NULL
)
4936 reply
= g_dbus_message_new_method_error (message
,
4937 "org.freedesktop.DBus.Error.UnknownMethod",
4938 _("No such method '%s'"),
4939 g_dbus_message_get_member (message
));
4940 g_dbus_connection_send_message_unlocked (connection
, reply
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, NULL
);
4941 g_object_unref (reply
);
4946 parameters
= g_dbus_message_get_body (message
);
4947 if (parameters
== NULL
)
4949 parameters
= g_variant_new ("()");
4950 g_variant_ref_sink (parameters
);
4954 g_variant_ref (parameters
);
4957 /* Check that the incoming args are of the right type - if they are not, return
4958 * the org.freedesktop.DBus.Error.InvalidArgs error to the caller
4960 in_type
= _g_dbus_compute_complete_signature (method_info
->in_args
);
4961 if (!g_variant_is_of_type (parameters
, in_type
))
4965 type_string
= g_variant_type_dup_string (in_type
);
4967 reply
= g_dbus_message_new_method_error (message
,
4968 "org.freedesktop.DBus.Error.InvalidArgs",
4969 _("Type of message, '%s', does not match expected type '%s'"),
4970 g_variant_get_type_string (parameters
),
4972 g_dbus_connection_send_message_unlocked (connection
, reply
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, NULL
);
4973 g_variant_type_free (in_type
);
4974 g_variant_unref (parameters
);
4975 g_object_unref (reply
);
4976 g_free (type_string
);
4980 g_variant_type_free (in_type
);
4982 /* schedule the call in idle */
4983 schedule_method_call (connection
, message
, registration_id
, subtree_registration_id
,
4984 interface_info
, method_info
, NULL
, parameters
,
4985 vtable
, main_context
, user_data
);
4986 g_variant_unref (parameters
);
4993 /* ---------------------------------------------------------------------------------------------------- */
4995 /* called in GDBusWorker thread with connection's lock held */
4997 obj_message_func (GDBusConnection
*connection
,
4999 GDBusMessage
*message
)
5001 const gchar
*interface_name
;
5002 const gchar
*member
;
5003 const gchar
*signature
;
5008 interface_name
= g_dbus_message_get_interface (message
);
5009 member
= g_dbus_message_get_member (message
);
5010 signature
= g_dbus_message_get_signature (message
);
5012 /* see if we have an interface for handling this call */
5013 if (interface_name
!= NULL
)
5015 ExportedInterface
*ei
;
5016 ei
= g_hash_table_lookup (eo
->map_if_name_to_ei
, interface_name
);
5019 /* we do - invoke the handler in idle in the right thread */
5021 /* handle no vtable or handler being present */
5022 if (ei
->vtable
== NULL
|| ei
->vtable
->method_call
== NULL
)
5025 handled
= validate_and_maybe_schedule_method_call (connection
,
5037 if (g_strcmp0 (interface_name
, "org.freedesktop.DBus.Introspectable") == 0 &&
5038 g_strcmp0 (member
, "Introspect") == 0 &&
5039 g_strcmp0 (signature
, "") == 0)
5041 handled
= handle_introspect (connection
, eo
, message
);
5044 else if (g_strcmp0 (interface_name
, "org.freedesktop.DBus.Properties") == 0 &&
5045 g_strcmp0 (member
, "Get") == 0 &&
5046 g_strcmp0 (signature
, "ss") == 0)
5048 handled
= handle_getset_property (connection
, eo
, message
, TRUE
);
5051 else if (g_strcmp0 (interface_name
, "org.freedesktop.DBus.Properties") == 0 &&
5052 g_strcmp0 (member
, "Set") == 0 &&
5053 g_strcmp0 (signature
, "ssv") == 0)
5055 handled
= handle_getset_property (connection
, eo
, message
, FALSE
);
5058 else if (g_strcmp0 (interface_name
, "org.freedesktop.DBus.Properties") == 0 &&
5059 g_strcmp0 (member
, "GetAll") == 0 &&
5060 g_strcmp0 (signature
, "s") == 0)
5062 handled
= handle_get_all_properties (connection
, eo
, message
);
5071 * g_dbus_connection_register_object:
5072 * @connection: a #GDBusConnection
5073 * @object_path: the object path to register at
5074 * @interface_info: introspection data for the interface
5075 * @vtable: (nullable): a #GDBusInterfaceVTable to call into or %NULL
5076 * @user_data: (nullable): data to pass to functions in @vtable
5077 * @user_data_free_func: function to call when the object path is unregistered
5078 * @error: return location for error or %NULL
5080 * Registers callbacks for exported objects at @object_path with the
5081 * D-Bus interface that is described in @interface_info.
5083 * Calls to functions in @vtable (and @user_data_free_func) will happen
5085 * [thread-default main context][g-main-context-push-thread-default]
5086 * of the thread you are calling this method from.
5088 * Note that all #GVariant values passed to functions in @vtable will match
5089 * the signature given in @interface_info - if a remote caller passes
5090 * incorrect values, the `org.freedesktop.DBus.Error.InvalidArgs`
5091 * is returned to the remote caller.
5093 * Additionally, if the remote caller attempts to invoke methods or
5094 * access properties not mentioned in @interface_info the
5095 * `org.freedesktop.DBus.Error.UnknownMethod` resp.
5096 * `org.freedesktop.DBus.Error.InvalidArgs` errors
5097 * are returned to the caller.
5099 * It is considered a programming error if the
5100 * #GDBusInterfaceGetPropertyFunc function in @vtable returns a
5101 * #GVariant of incorrect type.
5103 * If an existing callback is already registered at @object_path and
5104 * @interface_name, then @error is set to #G_IO_ERROR_EXISTS.
5106 * GDBus automatically implements the standard D-Bus interfaces
5107 * org.freedesktop.DBus.Properties, org.freedesktop.DBus.Introspectable
5108 * and org.freedesktop.Peer, so you don't have to implement those for the
5109 * objects you export. You can implement org.freedesktop.DBus.Properties
5110 * yourself, e.g. to handle getting and setting of properties asynchronously.
5112 * Note that the reference count on @interface_info will be
5113 * incremented by 1 (unless allocated statically, e.g. if the
5114 * reference count is -1, see g_dbus_interface_info_ref()) for as long
5115 * as the object is exported. Also note that @vtable will be copied.
5117 * See this [server][gdbus-server] for an example of how to use this method.
5119 * Returns: 0 if @error is set, otherwise a registration id (never 0)
5120 * that can be used with g_dbus_connection_unregister_object()
5125 g_dbus_connection_register_object (GDBusConnection
*connection
,
5126 const gchar
*object_path
,
5127 GDBusInterfaceInfo
*interface_info
,
5128 const GDBusInterfaceVTable
*vtable
,
5130 GDestroyNotify user_data_free_func
,
5134 ExportedInterface
*ei
;
5137 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), 0);
5138 g_return_val_if_fail (object_path
!= NULL
&& g_variant_is_object_path (object_path
), 0);
5139 g_return_val_if_fail (interface_info
!= NULL
, 0);
5140 g_return_val_if_fail (g_dbus_is_interface_name (interface_info
->name
), 0);
5141 g_return_val_if_fail (error
== NULL
|| *error
== NULL
, 0);
5142 g_return_val_if_fail (check_initialized (connection
), 0);
5146 CONNECTION_LOCK (connection
);
5148 eo
= g_hash_table_lookup (connection
->map_object_path_to_eo
, object_path
);
5151 eo
= g_new0 (ExportedObject
, 1);
5152 eo
->object_path
= g_strdup (object_path
);
5153 eo
->connection
= connection
;
5154 eo
->map_if_name_to_ei
= g_hash_table_new_full (g_str_hash
,
5157 (GDestroyNotify
) exported_interface_free
);
5158 g_hash_table_insert (connection
->map_object_path_to_eo
, eo
->object_path
, eo
);
5161 ei
= g_hash_table_lookup (eo
->map_if_name_to_ei
, interface_info
->name
);
5167 _("An object is already exported for the interface %s at %s"),
5168 interface_info
->name
,
5173 ei
= g_new0 (ExportedInterface
, 1);
5174 ei
->id
= g_atomic_int_add (&_global_registration_id
, 1); /* TODO: overflow etc. */
5176 ei
->user_data
= user_data
;
5177 ei
->user_data_free_func
= user_data_free_func
;
5178 ei
->vtable
= _g_dbus_interface_vtable_copy (vtable
);
5179 ei
->interface_info
= g_dbus_interface_info_ref (interface_info
);
5180 g_dbus_interface_info_cache_build (ei
->interface_info
);
5181 ei
->interface_name
= g_strdup (interface_info
->name
);
5182 ei
->context
= g_main_context_ref_thread_default ();
5184 g_hash_table_insert (eo
->map_if_name_to_ei
,
5185 (gpointer
) ei
->interface_name
,
5187 g_hash_table_insert (connection
->map_id_to_ei
,
5188 GUINT_TO_POINTER (ei
->id
),
5194 CONNECTION_UNLOCK (connection
);
5200 * g_dbus_connection_unregister_object:
5201 * @connection: a #GDBusConnection
5202 * @registration_id: a registration id obtained from
5203 * g_dbus_connection_register_object()
5205 * Unregisters an object.
5207 * Returns: %TRUE if the object was unregistered, %FALSE otherwise
5212 g_dbus_connection_unregister_object (GDBusConnection
*connection
,
5213 guint registration_id
)
5215 ExportedInterface
*ei
;
5219 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), FALSE
);
5220 g_return_val_if_fail (check_initialized (connection
), FALSE
);
5224 CONNECTION_LOCK (connection
);
5226 ei
= g_hash_table_lookup (connection
->map_id_to_ei
,
5227 GUINT_TO_POINTER (registration_id
));
5233 g_warn_if_fail (g_hash_table_remove (connection
->map_id_to_ei
, GUINT_TO_POINTER (ei
->id
)));
5234 g_warn_if_fail (g_hash_table_remove (eo
->map_if_name_to_ei
, ei
->interface_name
));
5235 /* unregister object path if we have no more exported interfaces */
5236 if (g_hash_table_size (eo
->map_if_name_to_ei
) == 0)
5237 g_warn_if_fail (g_hash_table_remove (connection
->map_object_path_to_eo
,
5243 CONNECTION_UNLOCK (connection
);
5249 GClosure
*method_call_closure
;
5250 GClosure
*get_property_closure
;
5251 GClosure
*set_property_closure
;
5252 } RegisterObjectData
;
5254 static RegisterObjectData
*
5255 register_object_data_new (GClosure
*method_call_closure
,
5256 GClosure
*get_property_closure
,
5257 GClosure
*set_property_closure
)
5259 RegisterObjectData
*data
;
5261 data
= g_new0 (RegisterObjectData
, 1);
5263 if (method_call_closure
!= NULL
)
5265 data
->method_call_closure
= g_closure_ref (method_call_closure
);
5266 g_closure_sink (method_call_closure
);
5267 if (G_CLOSURE_NEEDS_MARSHAL (method_call_closure
))
5268 g_closure_set_marshal (method_call_closure
, g_cclosure_marshal_generic
);
5271 if (get_property_closure
!= NULL
)
5273 data
->get_property_closure
= g_closure_ref (get_property_closure
);
5274 g_closure_sink (get_property_closure
);
5275 if (G_CLOSURE_NEEDS_MARSHAL (get_property_closure
))
5276 g_closure_set_marshal (get_property_closure
, g_cclosure_marshal_generic
);
5279 if (set_property_closure
!= NULL
)
5281 data
->set_property_closure
= g_closure_ref (set_property_closure
);
5282 g_closure_sink (set_property_closure
);
5283 if (G_CLOSURE_NEEDS_MARSHAL (set_property_closure
))
5284 g_closure_set_marshal (set_property_closure
, g_cclosure_marshal_generic
);
5291 register_object_free_func (gpointer user_data
)
5293 RegisterObjectData
*data
= user_data
;
5295 g_clear_pointer (&data
->method_call_closure
, g_closure_unref
);
5296 g_clear_pointer (&data
->get_property_closure
, g_closure_unref
);
5297 g_clear_pointer (&data
->set_property_closure
, g_closure_unref
);
5303 register_with_closures_on_method_call (GDBusConnection
*connection
,
5304 const gchar
*sender
,
5305 const gchar
*object_path
,
5306 const gchar
*interface_name
,
5307 const gchar
*method_name
,
5308 GVariant
*parameters
,
5309 GDBusMethodInvocation
*invocation
,
5312 RegisterObjectData
*data
= user_data
;
5313 GValue params
[] = { G_VALUE_INIT
, G_VALUE_INIT
, G_VALUE_INIT
, G_VALUE_INIT
, G_VALUE_INIT
, G_VALUE_INIT
, G_VALUE_INIT
};
5315 g_value_init (¶ms
[0], G_TYPE_DBUS_CONNECTION
);
5316 g_value_set_object (¶ms
[0], connection
);
5318 g_value_init (¶ms
[1], G_TYPE_STRING
);
5319 g_value_set_string (¶ms
[1], sender
);
5321 g_value_init (¶ms
[2], G_TYPE_STRING
);
5322 g_value_set_string (¶ms
[2], object_path
);
5324 g_value_init (¶ms
[3], G_TYPE_STRING
);
5325 g_value_set_string (¶ms
[3], interface_name
);
5327 g_value_init (¶ms
[4], G_TYPE_STRING
);
5328 g_value_set_string (¶ms
[4], method_name
);
5330 g_value_init (¶ms
[5], G_TYPE_VARIANT
);
5331 g_value_set_variant (¶ms
[5], parameters
);
5333 g_value_init (¶ms
[6], G_TYPE_DBUS_METHOD_INVOCATION
);
5334 g_value_set_object (¶ms
[6], invocation
);
5336 g_closure_invoke (data
->method_call_closure
, NULL
, G_N_ELEMENTS (params
), params
, NULL
);
5338 g_value_unset (params
+ 0);
5339 g_value_unset (params
+ 1);
5340 g_value_unset (params
+ 2);
5341 g_value_unset (params
+ 3);
5342 g_value_unset (params
+ 4);
5343 g_value_unset (params
+ 5);
5344 g_value_unset (params
+ 6);
5348 register_with_closures_on_get_property (GDBusConnection
*connection
,
5349 const gchar
*sender
,
5350 const gchar
*object_path
,
5351 const gchar
*interface_name
,
5352 const gchar
*property_name
,
5356 RegisterObjectData
*data
= user_data
;
5357 GValue params
[] = { G_VALUE_INIT
, G_VALUE_INIT
, G_VALUE_INIT
, G_VALUE_INIT
, G_VALUE_INIT
};
5358 GValue result_value
= G_VALUE_INIT
;
5361 g_value_init (¶ms
[0], G_TYPE_DBUS_CONNECTION
);
5362 g_value_set_object (¶ms
[0], connection
);
5364 g_value_init (¶ms
[1], G_TYPE_STRING
);
5365 g_value_set_string (¶ms
[1], sender
);
5367 g_value_init (¶ms
[2], G_TYPE_STRING
);
5368 g_value_set_string (¶ms
[2], object_path
);
5370 g_value_init (¶ms
[3], G_TYPE_STRING
);
5371 g_value_set_string (¶ms
[3], interface_name
);
5373 g_value_init (¶ms
[4], G_TYPE_STRING
);
5374 g_value_set_string (¶ms
[4], property_name
);
5376 g_value_init (&result_value
, G_TYPE_VARIANT
);
5378 g_closure_invoke (data
->get_property_closure
, &result_value
, G_N_ELEMENTS (params
), params
, NULL
);
5380 result
= g_value_get_variant (&result_value
);
5382 g_variant_ref (result
);
5384 g_value_unset (params
+ 0);
5385 g_value_unset (params
+ 1);
5386 g_value_unset (params
+ 2);
5387 g_value_unset (params
+ 3);
5388 g_value_unset (params
+ 4);
5389 g_value_unset (&result_value
);
5392 g_set_error (error
, G_DBUS_ERROR
, G_DBUS_ERROR_FAILED
,
5393 _("Unable to retrieve property %s.%s"),
5394 interface_name
, property_name
);
5400 register_with_closures_on_set_property (GDBusConnection
*connection
,
5401 const gchar
*sender
,
5402 const gchar
*object_path
,
5403 const gchar
*interface_name
,
5404 const gchar
*property_name
,
5409 RegisterObjectData
*data
= user_data
;
5410 GValue params
[] = { G_VALUE_INIT
, G_VALUE_INIT
, G_VALUE_INIT
, G_VALUE_INIT
, G_VALUE_INIT
, G_VALUE_INIT
};
5411 GValue result_value
= G_VALUE_INIT
;
5414 g_value_init (¶ms
[0], G_TYPE_DBUS_CONNECTION
);
5415 g_value_set_object (¶ms
[0], connection
);
5417 g_value_init (¶ms
[1], G_TYPE_STRING
);
5418 g_value_set_string (¶ms
[1], sender
);
5420 g_value_init (¶ms
[2], G_TYPE_STRING
);
5421 g_value_set_string (¶ms
[2], object_path
);
5423 g_value_init (¶ms
[3], G_TYPE_STRING
);
5424 g_value_set_string (¶ms
[3], interface_name
);
5426 g_value_init (¶ms
[4], G_TYPE_STRING
);
5427 g_value_set_string (¶ms
[4], property_name
);
5429 g_value_init (¶ms
[5], G_TYPE_VARIANT
);
5430 g_value_set_variant (¶ms
[5], value
);
5432 g_value_init (&result_value
, G_TYPE_BOOLEAN
);
5434 g_closure_invoke (data
->set_property_closure
, &result_value
, G_N_ELEMENTS (params
), params
, NULL
);
5436 result
= g_value_get_boolean (&result_value
);
5438 g_value_unset (params
+ 0);
5439 g_value_unset (params
+ 1);
5440 g_value_unset (params
+ 2);
5441 g_value_unset (params
+ 3);
5442 g_value_unset (params
+ 4);
5443 g_value_unset (params
+ 5);
5444 g_value_unset (&result_value
);
5448 G_DBUS_ERROR
, G_DBUS_ERROR_FAILED
,
5449 _("Unable to set property %s.%s"),
5450 interface_name
, property_name
);
5456 * g_dbus_connection_register_object_with_closures: (rename-to g_dbus_connection_register_object)
5457 * @connection: A #GDBusConnection.
5458 * @object_path: The object path to register at.
5459 * @interface_info: Introspection data for the interface.
5460 * @method_call_closure: (nullable): #GClosure for handling incoming method calls.
5461 * @get_property_closure: (nullable): #GClosure for getting a property.
5462 * @set_property_closure: (nullable): #GClosure for setting a property.
5463 * @error: Return location for error or %NULL.
5465 * Version of g_dbus_connection_register_object() using closures instead of a
5466 * #GDBusInterfaceVTable for easier binding in other languages.
5468 * Returns: 0 if @error is set, otherwise a registration id (never 0)
5469 * that can be used with g_dbus_connection_unregister_object() .
5474 g_dbus_connection_register_object_with_closures (GDBusConnection
*connection
,
5475 const gchar
*object_path
,
5476 GDBusInterfaceInfo
*interface_info
,
5477 GClosure
*method_call_closure
,
5478 GClosure
*get_property_closure
,
5479 GClosure
*set_property_closure
,
5482 RegisterObjectData
*data
;
5483 GDBusInterfaceVTable vtable
=
5485 method_call_closure
!= NULL
? register_with_closures_on_method_call
: NULL
,
5486 get_property_closure
!= NULL
? register_with_closures_on_get_property
: NULL
,
5487 set_property_closure
!= NULL
? register_with_closures_on_set_property
: NULL
5490 data
= register_object_data_new (method_call_closure
, get_property_closure
, set_property_closure
);
5492 return g_dbus_connection_register_object (connection
,
5497 register_object_free_func
,
5501 /* ---------------------------------------------------------------------------------------------------- */
5504 * g_dbus_connection_emit_signal:
5505 * @connection: a #GDBusConnection
5506 * @destination_bus_name: (nullable): the unique bus name for the destination
5507 * for the signal or %NULL to emit to all listeners
5508 * @object_path: path of remote object
5509 * @interface_name: D-Bus interface to emit a signal on
5510 * @signal_name: the name of the signal to emit
5511 * @parameters: (nullable): a #GVariant tuple with parameters for the signal
5512 * or %NULL if not passing parameters
5513 * @error: Return location for error or %NULL
5517 * If the parameters GVariant is floating, it is consumed.
5519 * This can only fail if @parameters is not compatible with the D-Bus protocol.
5521 * Returns: %TRUE unless @error is set
5526 g_dbus_connection_emit_signal (GDBusConnection
*connection
,
5527 const gchar
*destination_bus_name
,
5528 const gchar
*object_path
,
5529 const gchar
*interface_name
,
5530 const gchar
*signal_name
,
5531 GVariant
*parameters
,
5534 GDBusMessage
*message
;
5540 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), FALSE
);
5541 g_return_val_if_fail (destination_bus_name
== NULL
|| g_dbus_is_name (destination_bus_name
), FALSE
);
5542 g_return_val_if_fail (object_path
!= NULL
&& g_variant_is_object_path (object_path
), FALSE
);
5543 g_return_val_if_fail (interface_name
!= NULL
&& g_dbus_is_interface_name (interface_name
), FALSE
);
5544 g_return_val_if_fail (signal_name
!= NULL
&& g_dbus_is_member_name (signal_name
), FALSE
);
5545 g_return_val_if_fail (parameters
== NULL
|| g_variant_is_of_type (parameters
, G_VARIANT_TYPE_TUPLE
), FALSE
);
5546 g_return_val_if_fail (check_initialized (connection
), FALSE
);
5548 if (G_UNLIKELY (_g_dbus_debug_emission ()))
5550 _g_dbus_debug_print_lock ();
5551 g_print ("========================================================================\n"
5552 "GDBus-debug:Emission:\n"
5553 " >>>> SIGNAL EMISSION %s.%s()\n"
5555 " destination %s\n",
5556 interface_name
, signal_name
,
5558 destination_bus_name
!= NULL
? destination_bus_name
: "(none)");
5559 _g_dbus_debug_print_unlock ();
5562 message
= g_dbus_message_new_signal (object_path
,
5566 if (destination_bus_name
!= NULL
)
5567 g_dbus_message_set_header (message
,
5568 G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION
,
5569 g_variant_new_string (destination_bus_name
));
5571 if (parameters
!= NULL
)
5572 g_dbus_message_set_body (message
, parameters
);
5574 ret
= g_dbus_connection_send_message (connection
, message
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, error
);
5575 g_object_unref (message
);
5581 add_call_flags (GDBusMessage
*message
,
5582 GDBusCallFlags flags
)
5584 GDBusMessageFlags msg_flags
= 0;
5586 if (flags
& G_DBUS_CALL_FLAGS_NO_AUTO_START
)
5587 msg_flags
|= G_DBUS_MESSAGE_FLAGS_NO_AUTO_START
;
5588 if (flags
& G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION
)
5589 msg_flags
|= G_DBUS_MESSAGE_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION
;
5591 g_dbus_message_set_flags (message
, msg_flags
);
5595 decode_method_reply (GDBusMessage
*reply
,
5596 const gchar
*method_name
,
5597 const GVariantType
*reply_type
,
5598 GUnixFDList
**out_fd_list
,
5604 switch (g_dbus_message_get_message_type (reply
))
5606 case G_DBUS_MESSAGE_TYPE_METHOD_RETURN
:
5607 result
= g_dbus_message_get_body (reply
);
5610 result
= g_variant_new ("()");
5611 g_variant_ref_sink (result
);
5615 g_variant_ref (result
);
5618 if (!g_variant_is_of_type (result
, reply_type
))
5620 gchar
*type_string
= g_variant_type_dup_string (reply_type
);
5624 G_IO_ERROR_INVALID_ARGUMENT
,
5625 _("Method '%s' returned type '%s', but expected '%s'"),
5626 method_name
, g_variant_get_type_string (result
), type_string
);
5628 g_variant_unref (result
);
5629 g_free (type_string
);
5636 if (out_fd_list
!= NULL
)
5638 *out_fd_list
= g_dbus_message_get_unix_fd_list (reply
);
5639 if (*out_fd_list
!= NULL
)
5640 g_object_ref (*out_fd_list
);
5646 case G_DBUS_MESSAGE_TYPE_ERROR
:
5647 g_dbus_message_to_gerror (reply
, error
);
5651 g_assert_not_reached ();
5661 GVariantType
*reply_type
;
5662 gchar
*method_name
; /* for error message */
5664 GUnixFDList
*fd_list
;
5668 call_state_free (CallState
*state
)
5670 g_variant_type_free (state
->reply_type
);
5671 g_free (state
->method_name
);
5673 if (state
->fd_list
!= NULL
)
5674 g_object_unref (state
->fd_list
);
5675 g_slice_free (CallState
, state
);
5678 /* called in any thread, with the connection's lock not held */
5680 g_dbus_connection_call_done (GObject
*source
,
5681 GAsyncResult
*result
,
5684 GDBusConnection
*connection
= G_DBUS_CONNECTION (source
);
5685 GTask
*task
= user_data
;
5686 CallState
*state
= g_task_get_task_data (task
);
5687 GError
*error
= NULL
;
5688 GDBusMessage
*reply
;
5689 GVariant
*value
= NULL
;
5691 reply
= g_dbus_connection_send_message_with_reply_finish (connection
,
5695 if (G_UNLIKELY (_g_dbus_debug_call ()))
5697 _g_dbus_debug_print_lock ();
5698 g_print ("========================================================================\n"
5699 "GDBus-debug:Call:\n"
5700 " <<<< ASYNC COMPLETE %s() (serial %d)\n"
5703 g_dbus_message_get_reply_serial (reply
));
5706 g_print ("SUCCESS\n");
5710 g_print ("FAILED: %s\n",
5713 _g_dbus_debug_print_unlock ();
5717 value
= decode_method_reply (reply
, state
->method_name
, state
->reply_type
, &state
->fd_list
, &error
);
5720 g_task_return_error (task
, error
);
5722 g_task_return_pointer (task
, value
, (GDestroyNotify
) g_variant_unref
);
5724 g_clear_object (&reply
);
5725 g_object_unref (task
);
5728 /* called in any thread, with the connection's lock not held */
5730 g_dbus_connection_call_internal (GDBusConnection
*connection
,
5731 const gchar
*bus_name
,
5732 const gchar
*object_path
,
5733 const gchar
*interface_name
,
5734 const gchar
*method_name
,
5735 GVariant
*parameters
,
5736 const GVariantType
*reply_type
,
5737 GDBusCallFlags flags
,
5739 GUnixFDList
*fd_list
,
5740 GCancellable
*cancellable
,
5741 GAsyncReadyCallback callback
,
5744 GDBusMessage
*message
;
5747 g_return_if_fail (G_IS_DBUS_CONNECTION (connection
));
5748 g_return_if_fail (bus_name
== NULL
|| g_dbus_is_name (bus_name
));
5749 g_return_if_fail (object_path
!= NULL
&& g_variant_is_object_path (object_path
));
5750 g_return_if_fail (interface_name
!= NULL
&& g_dbus_is_interface_name (interface_name
));
5751 g_return_if_fail (method_name
!= NULL
&& g_dbus_is_member_name (method_name
));
5752 g_return_if_fail (timeout_msec
>= 0 || timeout_msec
== -1);
5753 g_return_if_fail ((parameters
== NULL
) || g_variant_is_of_type (parameters
, G_VARIANT_TYPE_TUPLE
));
5754 g_return_if_fail (check_initialized (connection
));
5756 g_return_if_fail (fd_list
== NULL
|| G_IS_UNIX_FD_LIST (fd_list
));
5758 g_return_if_fail (fd_list
== NULL
);
5761 message
= g_dbus_message_new_method_call (bus_name
,
5765 add_call_flags (message
, flags
);
5766 if (parameters
!= NULL
)
5767 g_dbus_message_set_body (message
, parameters
);
5770 if (fd_list
!= NULL
)
5771 g_dbus_message_set_unix_fd_list (message
, fd_list
);
5774 /* If the user has no callback then we can just send the message with
5775 * the G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set and skip all
5776 * the logic for processing the reply. If the service sends the reply
5777 * anyway then it will just be ignored.
5779 if (callback
!= NULL
)
5784 state
= g_slice_new0 (CallState
);
5785 state
->method_name
= g_strjoin (".", interface_name
, method_name
, NULL
);
5787 if (reply_type
== NULL
)
5788 reply_type
= G_VARIANT_TYPE_ANY
;
5790 state
->reply_type
= g_variant_type_copy (reply_type
);
5792 task
= g_task_new (connection
, cancellable
, callback
, user_data
);
5793 g_task_set_source_tag (task
, g_dbus_connection_call_internal
);
5794 g_task_set_task_data (task
, state
, (GDestroyNotify
) call_state_free
);
5796 g_dbus_connection_send_message_with_reply (connection
,
5798 G_DBUS_SEND_MESSAGE_FLAGS_NONE
,
5802 g_dbus_connection_call_done
,
5807 GDBusMessageFlags flags
;
5809 flags
= g_dbus_message_get_flags (message
);
5810 flags
|= G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED
;
5811 g_dbus_message_set_flags (message
, flags
);
5813 g_dbus_connection_send_message (connection
,
5815 G_DBUS_SEND_MESSAGE_FLAGS_NONE
,
5819 if (G_UNLIKELY (_g_dbus_debug_call ()))
5821 _g_dbus_debug_print_lock ();
5822 g_print ("========================================================================\n"
5823 "GDBus-debug:Call:\n"
5824 " >>>> ASYNC %s.%s()\n"
5826 " owned by name %s (serial %d)\n",
5830 bus_name
!= NULL
? bus_name
: "(none)",
5832 _g_dbus_debug_print_unlock ();
5835 if (message
!= NULL
)
5836 g_object_unref (message
);
5839 /* called in any thread, with the connection's lock not held */
5841 g_dbus_connection_call_finish_internal (GDBusConnection
*connection
,
5842 GUnixFDList
**out_fd_list
,
5850 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), NULL
);
5851 g_return_val_if_fail (g_task_is_valid (res
, connection
), NULL
);
5852 g_return_val_if_fail (error
== NULL
|| *error
== NULL
, NULL
);
5854 task
= G_TASK (res
);
5855 state
= g_task_get_task_data (task
);
5857 ret
= g_task_propagate_pointer (task
, error
);
5861 if (out_fd_list
!= NULL
)
5862 *out_fd_list
= state
->fd_list
!= NULL
? g_object_ref (state
->fd_list
) : NULL
;
5866 /* called in any user thread, with the connection's lock not held */
5868 g_dbus_connection_call_sync_internal (GDBusConnection
*connection
,
5869 const gchar
*bus_name
,
5870 const gchar
*object_path
,
5871 const gchar
*interface_name
,
5872 const gchar
*method_name
,
5873 GVariant
*parameters
,
5874 const GVariantType
*reply_type
,
5875 GDBusCallFlags flags
,
5877 GUnixFDList
*fd_list
,
5878 GUnixFDList
**out_fd_list
,
5879 GCancellable
*cancellable
,
5882 GDBusMessage
*message
;
5883 GDBusMessage
*reply
;
5885 GError
*local_error
;
5886 GDBusSendMessageFlags send_flags
;
5892 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), NULL
);
5893 g_return_val_if_fail (bus_name
== NULL
|| g_dbus_is_name (bus_name
), NULL
);
5894 g_return_val_if_fail (object_path
!= NULL
&& g_variant_is_object_path (object_path
), NULL
);
5895 g_return_val_if_fail (interface_name
!= NULL
&& g_dbus_is_interface_name (interface_name
), NULL
);
5896 g_return_val_if_fail (method_name
!= NULL
&& g_dbus_is_member_name (method_name
), NULL
);
5897 g_return_val_if_fail (timeout_msec
>= 0 || timeout_msec
== -1, NULL
);
5898 g_return_val_if_fail ((parameters
== NULL
) || g_variant_is_of_type (parameters
, G_VARIANT_TYPE_TUPLE
), NULL
);
5900 g_return_val_if_fail (fd_list
== NULL
|| G_IS_UNIX_FD_LIST (fd_list
), NULL
);
5902 g_return_val_if_fail (fd_list
== NULL
, NULL
);
5904 g_return_val_if_fail (error
== NULL
|| *error
== NULL
, NULL
);
5906 if (!(flags
& CALL_FLAGS_INITIALIZING
))
5907 g_return_val_if_fail (check_initialized (connection
), FALSE
);
5909 if (reply_type
== NULL
)
5910 reply_type
= G_VARIANT_TYPE_ANY
;
5912 message
= g_dbus_message_new_method_call (bus_name
,
5916 add_call_flags (message
, flags
);
5917 if (parameters
!= NULL
)
5918 g_dbus_message_set_body (message
, parameters
);
5921 if (fd_list
!= NULL
)
5922 g_dbus_message_set_unix_fd_list (message
, fd_list
);
5925 if (G_UNLIKELY (_g_dbus_debug_call ()))
5927 _g_dbus_debug_print_lock ();
5928 g_print ("========================================================================\n"
5929 "GDBus-debug:Call:\n"
5930 " >>>> SYNC %s.%s()\n"
5932 " owned by name %s\n",
5936 bus_name
!= NULL
? bus_name
: "(none)");
5937 _g_dbus_debug_print_unlock ();
5942 send_flags
= G_DBUS_SEND_MESSAGE_FLAGS_NONE
;
5944 /* translate from one flavour of flags to another... */
5945 if (flags
& CALL_FLAGS_INITIALIZING
)
5946 send_flags
|= SEND_MESSAGE_FLAGS_INITIALIZING
;
5948 reply
= g_dbus_connection_send_message_with_reply_sync (connection
,
5952 NULL
, /* volatile guint32 *out_serial */
5956 if (G_UNLIKELY (_g_dbus_debug_call ()))
5958 _g_dbus_debug_print_lock ();
5959 g_print ("========================================================================\n"
5960 "GDBus-debug:Call:\n"
5961 " <<<< SYNC COMPLETE %s.%s()\n"
5967 g_print ("SUCCESS\n");
5971 g_print ("FAILED: %s\n",
5972 local_error
->message
);
5974 _g_dbus_debug_print_unlock ();
5980 *error
= local_error
;
5982 g_error_free (local_error
);
5986 result
= decode_method_reply (reply
, method_name
, reply_type
, out_fd_list
, error
);
5989 if (message
!= NULL
)
5990 g_object_unref (message
);
5992 g_object_unref (reply
);
5997 /* ---------------------------------------------------------------------------------------------------- */
6000 * g_dbus_connection_call:
6001 * @connection: a #GDBusConnection
6002 * @bus_name: (nullable): a unique or well-known bus name or %NULL if
6003 * @connection is not a message bus connection
6004 * @object_path: path of remote object
6005 * @interface_name: D-Bus interface to invoke method on
6006 * @method_name: the name of the method to invoke
6007 * @parameters: (nullable): a #GVariant tuple with parameters for the method
6008 * or %NULL if not passing parameters
6009 * @reply_type: (nullable): the expected type of the reply, or %NULL
6010 * @flags: flags from the #GDBusCallFlags enumeration
6011 * @timeout_msec: the timeout in milliseconds, -1 to use the default
6012 * timeout or %G_MAXINT for no timeout
6013 * @cancellable: (nullable): a #GCancellable or %NULL
6014 * @callback: (nullable): a #GAsyncReadyCallback to call when the request
6015 * is satisfied or %NULL if you don't care about the result of the
6017 * @user_data: the data to pass to @callback
6019 * Asynchronously invokes the @method_name method on the
6020 * @interface_name D-Bus interface on the remote object at
6021 * @object_path owned by @bus_name.
6023 * If @connection is closed then the operation will fail with
6024 * %G_IO_ERROR_CLOSED. If @cancellable is canceled, the operation will
6025 * fail with %G_IO_ERROR_CANCELLED. If @parameters contains a value
6026 * not compatible with the D-Bus protocol, the operation fails with
6027 * %G_IO_ERROR_INVALID_ARGUMENT.
6029 * If @reply_type is non-%NULL then the reply will be checked for having this type and an
6030 * error will be raised if it does not match. Said another way, if you give a @reply_type
6031 * then any non-%NULL return value will be of this type.
6033 * If the @parameters #GVariant is floating, it is consumed. This allows
6034 * convenient 'inline' use of g_variant_new(), e.g.:
6035 * |[<!-- language="C" -->
6036 * g_dbus_connection_call (connection,
6037 * "org.freedesktop.StringThings",
6038 * "/org/freedesktop/StringThings",
6039 * "org.freedesktop.StringThings",
6041 * g_variant_new ("(ss)",
6045 * G_DBUS_CALL_FLAGS_NONE,
6048 * (GAsyncReadyCallback) two_strings_done,
6052 * This is an asynchronous method. When the operation is finished,
6053 * @callback will be invoked in the
6054 * [thread-default main context][g-main-context-push-thread-default]
6055 * of the thread you are calling this method from. You can then call
6056 * g_dbus_connection_call_finish() to get the result of the operation.
6057 * See g_dbus_connection_call_sync() for the synchronous version of this
6060 * If @callback is %NULL then the D-Bus method call message will be sent with
6061 * the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set.
6066 g_dbus_connection_call (GDBusConnection
*connection
,
6067 const gchar
*bus_name
,
6068 const gchar
*object_path
,
6069 const gchar
*interface_name
,
6070 const gchar
*method_name
,
6071 GVariant
*parameters
,
6072 const GVariantType
*reply_type
,
6073 GDBusCallFlags flags
,
6075 GCancellable
*cancellable
,
6076 GAsyncReadyCallback callback
,
6079 g_dbus_connection_call_internal (connection
, bus_name
, object_path
, interface_name
, method_name
, parameters
, reply_type
, flags
, timeout_msec
, NULL
, cancellable
, callback
, user_data
);
6083 * g_dbus_connection_call_finish:
6084 * @connection: a #GDBusConnection
6085 * @res: a #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_connection_call()
6086 * @error: return location for error or %NULL
6088 * Finishes an operation started with g_dbus_connection_call().
6090 * Returns: %NULL if @error is set. Otherwise a #GVariant tuple with
6091 * return values. Free with g_variant_unref().
6096 g_dbus_connection_call_finish (GDBusConnection
*connection
,
6100 return g_dbus_connection_call_finish_internal (connection
, NULL
, res
, error
);
6104 * g_dbus_connection_call_sync:
6105 * @connection: a #GDBusConnection
6106 * @bus_name: (nullable): a unique or well-known bus name or %NULL if
6107 * @connection is not a message bus connection
6108 * @object_path: path of remote object
6109 * @interface_name: D-Bus interface to invoke method on
6110 * @method_name: the name of the method to invoke
6111 * @parameters: (nullable): a #GVariant tuple with parameters for the method
6112 * or %NULL if not passing parameters
6113 * @reply_type: (nullable): the expected type of the reply, or %NULL
6114 * @flags: flags from the #GDBusCallFlags enumeration
6115 * @timeout_msec: the timeout in milliseconds, -1 to use the default
6116 * timeout or %G_MAXINT for no timeout
6117 * @cancellable: (nullable): a #GCancellable or %NULL
6118 * @error: return location for error or %NULL
6120 * Synchronously invokes the @method_name method on the
6121 * @interface_name D-Bus interface on the remote object at
6122 * @object_path owned by @bus_name.
6124 * If @connection is closed then the operation will fail with
6125 * %G_IO_ERROR_CLOSED. If @cancellable is canceled, the
6126 * operation will fail with %G_IO_ERROR_CANCELLED. If @parameters
6127 * contains a value not compatible with the D-Bus protocol, the operation
6128 * fails with %G_IO_ERROR_INVALID_ARGUMENT.
6130 * If @reply_type is non-%NULL then the reply will be checked for having
6131 * this type and an error will be raised if it does not match. Said
6132 * another way, if you give a @reply_type then any non-%NULL return
6133 * value will be of this type.
6135 * If the @parameters #GVariant is floating, it is consumed.
6136 * This allows convenient 'inline' use of g_variant_new(), e.g.:
6137 * |[<!-- language="C" -->
6138 * g_dbus_connection_call_sync (connection,
6139 * "org.freedesktop.StringThings",
6140 * "/org/freedesktop/StringThings",
6141 * "org.freedesktop.StringThings",
6143 * g_variant_new ("(ss)",
6147 * G_DBUS_CALL_FLAGS_NONE,
6153 * The calling thread is blocked until a reply is received. See
6154 * g_dbus_connection_call() for the asynchronous version of
6157 * Returns: %NULL if @error is set. Otherwise a #GVariant tuple with
6158 * return values. Free with g_variant_unref().
6163 g_dbus_connection_call_sync (GDBusConnection
*connection
,
6164 const gchar
*bus_name
,
6165 const gchar
*object_path
,
6166 const gchar
*interface_name
,
6167 const gchar
*method_name
,
6168 GVariant
*parameters
,
6169 const GVariantType
*reply_type
,
6170 GDBusCallFlags flags
,
6172 GCancellable
*cancellable
,
6175 return g_dbus_connection_call_sync_internal (connection
, bus_name
, object_path
, interface_name
, method_name
, parameters
, reply_type
, flags
, timeout_msec
, NULL
, NULL
, cancellable
, error
);
6178 /* ---------------------------------------------------------------------------------------------------- */
6183 * g_dbus_connection_call_with_unix_fd_list:
6184 * @connection: a #GDBusConnection
6185 * @bus_name: (nullable): a unique or well-known bus name or %NULL if
6186 * @connection is not a message bus connection
6187 * @object_path: path of remote object
6188 * @interface_name: D-Bus interface to invoke method on
6189 * @method_name: the name of the method to invoke
6190 * @parameters: (nullable): a #GVariant tuple with parameters for the method
6191 * or %NULL if not passing parameters
6192 * @reply_type: (nullable): the expected type of the reply, or %NULL
6193 * @flags: flags from the #GDBusCallFlags enumeration
6194 * @timeout_msec: the timeout in milliseconds, -1 to use the default
6195 * timeout or %G_MAXINT for no timeout
6196 * @fd_list: (nullable): a #GUnixFDList or %NULL
6197 * @cancellable: (nullable): a #GCancellable or %NULL
6198 * @callback: (nullable): a #GAsyncReadyCallback to call when the request is
6199 * satisfied or %NULL if you don't * care about the result of the
6201 * @user_data: The data to pass to @callback.
6203 * Like g_dbus_connection_call() but also takes a #GUnixFDList object.
6205 * This method is only available on UNIX.
6210 g_dbus_connection_call_with_unix_fd_list (GDBusConnection
*connection
,
6211 const gchar
*bus_name
,
6212 const gchar
*object_path
,
6213 const gchar
*interface_name
,
6214 const gchar
*method_name
,
6215 GVariant
*parameters
,
6216 const GVariantType
*reply_type
,
6217 GDBusCallFlags flags
,
6219 GUnixFDList
*fd_list
,
6220 GCancellable
*cancellable
,
6221 GAsyncReadyCallback callback
,
6224 g_dbus_connection_call_internal (connection
, bus_name
, object_path
, interface_name
, method_name
, parameters
, reply_type
, flags
, timeout_msec
, fd_list
, cancellable
, callback
, user_data
);
6228 * g_dbus_connection_call_with_unix_fd_list_finish:
6229 * @connection: a #GDBusConnection
6230 * @out_fd_list: (out) (optional): return location for a #GUnixFDList or %NULL
6231 * @res: a #GAsyncResult obtained from the #GAsyncReadyCallback passed to
6232 * g_dbus_connection_call_with_unix_fd_list()
6233 * @error: return location for error or %NULL
6235 * Finishes an operation started with g_dbus_connection_call_with_unix_fd_list().
6237 * Returns: %NULL if @error is set. Otherwise a #GVariant tuple with
6238 * return values. Free with g_variant_unref().
6243 g_dbus_connection_call_with_unix_fd_list_finish (GDBusConnection
*connection
,
6244 GUnixFDList
**out_fd_list
,
6248 return g_dbus_connection_call_finish_internal (connection
, out_fd_list
, res
, error
);
6252 * g_dbus_connection_call_with_unix_fd_list_sync:
6253 * @connection: a #GDBusConnection
6254 * @bus_name: (nullable): a unique or well-known bus name or %NULL
6255 * if @connection is not a message bus connection
6256 * @object_path: path of remote object
6257 * @interface_name: D-Bus interface to invoke method on
6258 * @method_name: the name of the method to invoke
6259 * @parameters: (nullable): a #GVariant tuple with parameters for
6260 * the method or %NULL if not passing parameters
6261 * @reply_type: (nullable): the expected type of the reply, or %NULL
6262 * @flags: flags from the #GDBusCallFlags enumeration
6263 * @timeout_msec: the timeout in milliseconds, -1 to use the default
6264 * timeout or %G_MAXINT for no timeout
6265 * @fd_list: (nullable): a #GUnixFDList or %NULL
6266 * @out_fd_list: (out) (optional): return location for a #GUnixFDList or %NULL
6267 * @cancellable: (nullable): a #GCancellable or %NULL
6268 * @error: return location for error or %NULL
6270 * Like g_dbus_connection_call_sync() but also takes and returns #GUnixFDList objects.
6272 * This method is only available on UNIX.
6274 * Returns: %NULL if @error is set. Otherwise a #GVariant tuple with
6275 * return values. Free with g_variant_unref().
6280 g_dbus_connection_call_with_unix_fd_list_sync (GDBusConnection
*connection
,
6281 const gchar
*bus_name
,
6282 const gchar
*object_path
,
6283 const gchar
*interface_name
,
6284 const gchar
*method_name
,
6285 GVariant
*parameters
,
6286 const GVariantType
*reply_type
,
6287 GDBusCallFlags flags
,
6289 GUnixFDList
*fd_list
,
6290 GUnixFDList
**out_fd_list
,
6291 GCancellable
*cancellable
,
6294 return g_dbus_connection_call_sync_internal (connection
, bus_name
, object_path
, interface_name
, method_name
, parameters
, reply_type
, flags
, timeout_msec
, fd_list
, out_fd_list
, cancellable
, error
);
6297 #endif /* G_OS_UNIX */
6299 /* ---------------------------------------------------------------------------------------------------- */
6301 struct ExportedSubtree
6305 GDBusConnection
*connection
;
6306 GDBusSubtreeVTable
*vtable
;
6307 GDBusSubtreeFlags flags
;
6309 GMainContext
*context
;
6311 GDestroyNotify user_data_free_func
;
6315 exported_subtree_free (ExportedSubtree
*es
)
6317 call_destroy_notify (es
->context
,
6318 es
->user_data_free_func
,
6321 g_main_context_unref (es
->context
);
6323 _g_dbus_subtree_vtable_free (es
->vtable
);
6324 g_free (es
->object_path
);
6328 /* called without lock held in the thread where the caller registered
6332 handle_subtree_introspect (GDBusConnection
*connection
,
6333 ExportedSubtree
*es
,
6334 GDBusMessage
*message
)
6338 GDBusMessage
*reply
;
6341 const gchar
*sender
;
6342 const gchar
*requested_object_path
;
6343 const gchar
*requested_node
;
6344 GDBusInterfaceInfo
**interfaces
;
6346 gchar
**subnode_paths
;
6347 gboolean has_properties_interface
;
6348 gboolean has_introspectable_interface
;
6352 requested_object_path
= g_dbus_message_get_path (message
);
6353 sender
= g_dbus_message_get_sender (message
);
6354 is_root
= (g_strcmp0 (requested_object_path
, es
->object_path
) == 0);
6356 s
= g_string_new (NULL
);
6357 introspect_append_header (s
);
6359 /* Strictly we don't need the children in dynamic mode, but we avoid the
6360 * conditionals to preserve code clarity
6362 children
= es
->vtable
->enumerate (es
->connection
,
6369 requested_node
= strrchr (requested_object_path
, '/') + 1;
6371 /* Assert existence of object if we are not dynamic */
6372 if (!(es
->flags
& G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES
) &&
6373 !_g_strv_has_string ((const gchar
* const *) children
, requested_node
))
6378 requested_node
= NULL
;
6381 interfaces
= es
->vtable
->introspect (es
->connection
,
6386 if (interfaces
!= NULL
)
6388 has_properties_interface
= FALSE
;
6389 has_introspectable_interface
= FALSE
;
6391 for (n
= 0; interfaces
[n
] != NULL
; n
++)
6393 if (strcmp (interfaces
[n
]->name
, "org.freedesktop.DBus.Properties") == 0)
6394 has_properties_interface
= TRUE
;
6395 else if (strcmp (interfaces
[n
]->name
, "org.freedesktop.DBus.Introspectable") == 0)
6396 has_introspectable_interface
= TRUE
;
6398 if (!has_properties_interface
)
6399 g_string_append (s
, introspect_properties_interface
);
6400 if (!has_introspectable_interface
)
6401 g_string_append (s
, introspect_introspectable_interface
);
6403 for (n
= 0; interfaces
[n
] != NULL
; n
++)
6405 g_dbus_interface_info_generate_xml (interfaces
[n
], 2, s
);
6406 g_dbus_interface_info_unref (interfaces
[n
]);
6408 g_free (interfaces
);
6411 /* then include <node> entries from the Subtree for the root */
6414 for (n
= 0; children
!= NULL
&& children
[n
] != NULL
; n
++)
6415 g_string_append_printf (s
, " <node name=\"%s\"/>\n", children
[n
]);
6418 /* finally include nodes registered below us */
6419 subnode_paths
= g_dbus_connection_list_registered (es
->connection
, requested_object_path
);
6420 for (n
= 0; subnode_paths
!= NULL
&& subnode_paths
[n
] != NULL
; n
++)
6421 g_string_append_printf (s
, " <node name=\"%s\"/>\n", subnode_paths
[n
]);
6422 g_strfreev (subnode_paths
);
6424 g_string_append (s
, "</node>\n");
6426 reply
= g_dbus_message_new_method_reply (message
);
6427 g_dbus_message_set_body (reply
, g_variant_new ("(s)", s
->str
));
6428 g_dbus_connection_send_message (connection
, reply
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, NULL
);
6429 g_object_unref (reply
);
6434 g_string_free (s
, TRUE
);
6435 g_strfreev (children
);
6439 /* called without lock held in the thread where the caller registered
6443 handle_subtree_method_invocation (GDBusConnection
*connection
,
6444 ExportedSubtree
*es
,
6445 GDBusMessage
*message
)
6448 const gchar
*sender
;
6449 const gchar
*interface_name
;
6450 const gchar
*member
;
6451 const gchar
*signature
;
6452 const gchar
*requested_object_path
;
6453 const gchar
*requested_node
;
6455 GDBusInterfaceInfo
*interface_info
;
6456 const GDBusInterfaceVTable
*interface_vtable
;
6457 gpointer interface_user_data
;
6459 GDBusInterfaceInfo
**interfaces
;
6460 gboolean is_property_get
;
6461 gboolean is_property_set
;
6462 gboolean is_property_get_all
;
6467 requested_object_path
= g_dbus_message_get_path (message
);
6468 sender
= g_dbus_message_get_sender (message
);
6469 interface_name
= g_dbus_message_get_interface (message
);
6470 member
= g_dbus_message_get_member (message
);
6471 signature
= g_dbus_message_get_signature (message
);
6472 is_root
= (g_strcmp0 (requested_object_path
, es
->object_path
) == 0);
6474 is_property_get
= FALSE
;
6475 is_property_set
= FALSE
;
6476 is_property_get_all
= FALSE
;
6477 if (g_strcmp0 (interface_name
, "org.freedesktop.DBus.Properties") == 0)
6479 if (g_strcmp0 (member
, "Get") == 0 && g_strcmp0 (signature
, "ss") == 0)
6480 is_property_get
= TRUE
;
6481 else if (g_strcmp0 (member
, "Set") == 0 && g_strcmp0 (signature
, "ssv") == 0)
6482 is_property_set
= TRUE
;
6483 else if (g_strcmp0 (member
, "GetAll") == 0 && g_strcmp0 (signature
, "s") == 0)
6484 is_property_get_all
= TRUE
;
6489 requested_node
= strrchr (requested_object_path
, '/') + 1;
6491 if (~es
->flags
& G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES
)
6493 /* We don't want to dispatch to unenumerated
6494 * nodes, so ensure that the child exists.
6499 children
= es
->vtable
->enumerate (es
->connection
,
6504 exists
= _g_strv_has_string ((const gchar
* const *) children
, requested_node
);
6505 g_strfreev (children
);
6513 requested_node
= NULL
;
6516 /* get introspection data for the node */
6517 interfaces
= es
->vtable
->introspect (es
->connection
,
6519 requested_object_path
,
6523 if (interfaces
== NULL
)
6526 interface_info
= NULL
;
6527 for (n
= 0; interfaces
[n
] != NULL
; n
++)
6529 if (g_strcmp0 (interfaces
[n
]->name
, interface_name
) == 0)
6530 interface_info
= interfaces
[n
];
6533 /* dispatch the call if the user wants to handle it */
6534 if (interface_info
!= NULL
)
6536 /* figure out where to dispatch the method call */
6537 interface_user_data
= NULL
;
6538 interface_vtable
= es
->vtable
->dispatch (es
->connection
,
6543 &interface_user_data
,
6545 if (interface_vtable
== NULL
)
6548 CONNECTION_LOCK (connection
);
6549 handled
= validate_and_maybe_schedule_method_call (es
->connection
,
6556 interface_user_data
);
6557 CONNECTION_UNLOCK (connection
);
6559 /* handle org.freedesktop.DBus.Properties interface if not explicitly handled */
6560 else if (is_property_get
|| is_property_set
|| is_property_get_all
)
6562 if (is_property_get
)
6563 g_variant_get (g_dbus_message_get_body (message
), "(&s&s)", &interface_name
, NULL
);
6564 else if (is_property_set
)
6565 g_variant_get (g_dbus_message_get_body (message
), "(&s&sv)", &interface_name
, NULL
, NULL
);
6566 else if (is_property_get_all
)
6567 g_variant_get (g_dbus_message_get_body (message
), "(&s)", &interface_name
, NULL
, NULL
);
6569 g_assert_not_reached ();
6571 /* see if the object supports this interface at all */
6572 for (n
= 0; interfaces
[n
] != NULL
; n
++)
6574 if (g_strcmp0 (interfaces
[n
]->name
, interface_name
) == 0)
6575 interface_info
= interfaces
[n
];
6578 /* Fail with org.freedesktop.DBus.Error.InvalidArgs if the user-code
6579 * claims it won't support the interface
6581 if (interface_info
== NULL
)
6583 GDBusMessage
*reply
;
6584 reply
= g_dbus_message_new_method_error (message
,
6585 "org.freedesktop.DBus.Error.InvalidArgs",
6586 _("No such interface '%s'"),
6588 g_dbus_connection_send_message (es
->connection
, reply
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, NULL
);
6589 g_object_unref (reply
);
6594 /* figure out where to dispatch the property get/set/getall calls */
6595 interface_user_data
= NULL
;
6596 interface_vtable
= es
->vtable
->dispatch (es
->connection
,
6601 &interface_user_data
,
6603 if (interface_vtable
== NULL
)
6605 g_warning ("The subtree introspection function indicates that '%s' "
6606 "is a valid interface name, but calling the dispatch "
6607 "function on that interface gave us NULL", interface_name
);
6611 if (is_property_get
|| is_property_set
)
6613 CONNECTION_LOCK (connection
);
6614 handled
= validate_and_maybe_schedule_property_getset (es
->connection
,
6622 interface_user_data
);
6623 CONNECTION_UNLOCK (connection
);
6625 else if (is_property_get_all
)
6627 CONNECTION_LOCK (connection
);
6628 handled
= validate_and_maybe_schedule_property_get_all (es
->connection
,
6635 interface_user_data
);
6636 CONNECTION_UNLOCK (connection
);
6641 if (interfaces
!= NULL
)
6643 for (n
= 0; interfaces
[n
] != NULL
; n
++)
6644 g_dbus_interface_info_unref (interfaces
[n
]);
6645 g_free (interfaces
);
6653 GDBusMessage
*message
;
6654 ExportedSubtree
*es
;
6655 } SubtreeDeferredData
;
6658 subtree_deferred_data_free (SubtreeDeferredData
*data
)
6660 g_object_unref (data
->message
);
6664 /* called without lock held in the thread where the caller registered the subtree */
6666 process_subtree_vtable_message_in_idle_cb (gpointer _data
)
6668 SubtreeDeferredData
*data
= _data
;
6673 if (g_strcmp0 (g_dbus_message_get_interface (data
->message
), "org.freedesktop.DBus.Introspectable") == 0 &&
6674 g_strcmp0 (g_dbus_message_get_member (data
->message
), "Introspect") == 0 &&
6675 g_strcmp0 (g_dbus_message_get_signature (data
->message
), "") == 0)
6676 handled
= handle_subtree_introspect (data
->es
->connection
,
6680 handled
= handle_subtree_method_invocation (data
->es
->connection
,
6686 CONNECTION_LOCK (data
->es
->connection
);
6687 handled
= handle_generic_unlocked (data
->es
->connection
, data
->message
);
6688 CONNECTION_UNLOCK (data
->es
->connection
);
6691 /* if we couldn't handle the request, just bail with the UnknownMethod error */
6694 GDBusMessage
*reply
;
6695 reply
= g_dbus_message_new_method_error (data
->message
,
6696 "org.freedesktop.DBus.Error.UnknownMethod",
6697 _("Method '%s' on interface '%s' with signature '%s' does not exist"),
6698 g_dbus_message_get_member (data
->message
),
6699 g_dbus_message_get_interface (data
->message
),
6700 g_dbus_message_get_signature (data
->message
));
6701 g_dbus_connection_send_message (data
->es
->connection
, reply
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, NULL
);
6702 g_object_unref (reply
);
6708 /* called in GDBusWorker thread with connection's lock held */
6710 subtree_message_func (GDBusConnection
*connection
,
6711 ExportedSubtree
*es
,
6712 GDBusMessage
*message
)
6714 GSource
*idle_source
;
6715 SubtreeDeferredData
*data
;
6717 data
= g_new0 (SubtreeDeferredData
, 1);
6718 data
->message
= g_object_ref (message
);
6721 /* defer this call to an idle handler in the right thread */
6722 idle_source
= g_idle_source_new ();
6723 g_source_set_priority (idle_source
, G_PRIORITY_HIGH
);
6724 g_source_set_callback (idle_source
,
6725 process_subtree_vtable_message_in_idle_cb
,
6727 (GDestroyNotify
) subtree_deferred_data_free
);
6728 g_source_set_name (idle_source
, "[gio] process_subtree_vtable_message_in_idle_cb");
6729 g_source_attach (idle_source
, es
->context
);
6730 g_source_unref (idle_source
);
6732 /* since we own the entire subtree, handlers for objects not in the subtree have been
6733 * tried already by libdbus-1 - so we just need to ensure that we're always going
6734 * to reply to the message
6740 * g_dbus_connection_register_subtree:
6741 * @connection: a #GDBusConnection
6742 * @object_path: the object path to register the subtree at
6743 * @vtable: a #GDBusSubtreeVTable to enumerate, introspect and
6744 * dispatch nodes in the subtree
6745 * @flags: flags used to fine tune the behavior of the subtree
6746 * @user_data: data to pass to functions in @vtable
6747 * @user_data_free_func: function to call when the subtree is unregistered
6748 * @error: return location for error or %NULL
6750 * Registers a whole subtree of dynamic objects.
6752 * The @enumerate and @introspection functions in @vtable are used to
6753 * convey, to remote callers, what nodes exist in the subtree rooted
6756 * When handling remote calls into any node in the subtree, first the
6757 * @enumerate function is used to check if the node exists. If the node exists
6758 * or the #G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES flag is set
6759 * the @introspection function is used to check if the node supports the
6760 * requested method. If so, the @dispatch function is used to determine
6761 * where to dispatch the call. The collected #GDBusInterfaceVTable and
6762 * #gpointer will be used to call into the interface vtable for processing
6765 * All calls into user-provided code will be invoked in the
6766 * [thread-default main context][g-main-context-push-thread-default]
6767 * of the thread you are calling this method from.
6769 * If an existing subtree is already registered at @object_path or
6770 * then @error is set to #G_IO_ERROR_EXISTS.
6772 * Note that it is valid to register regular objects (using
6773 * g_dbus_connection_register_object()) in a subtree registered with
6774 * g_dbus_connection_register_subtree() - if so, the subtree handler
6775 * is tried as the last resort. One way to think about a subtree
6776 * handler is to consider it a fallback handler for object paths not
6777 * registered via g_dbus_connection_register_object() or other bindings.
6779 * Note that @vtable will be copied so you cannot change it after
6782 * See this [server][gdbus-subtree-server] for an example of how to use
6785 * Returns: 0 if @error is set, otherwise a subtree registration id (never 0)
6786 * that can be used with g_dbus_connection_unregister_subtree() .
6791 g_dbus_connection_register_subtree (GDBusConnection
*connection
,
6792 const gchar
*object_path
,
6793 const GDBusSubtreeVTable
*vtable
,
6794 GDBusSubtreeFlags flags
,
6796 GDestroyNotify user_data_free_func
,
6800 ExportedSubtree
*es
;
6802 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), 0);
6803 g_return_val_if_fail (object_path
!= NULL
&& g_variant_is_object_path (object_path
), 0);
6804 g_return_val_if_fail (vtable
!= NULL
, 0);
6805 g_return_val_if_fail (error
== NULL
|| *error
== NULL
, 0);
6806 g_return_val_if_fail (check_initialized (connection
), 0);
6810 CONNECTION_LOCK (connection
);
6812 es
= g_hash_table_lookup (connection
->map_object_path_to_es
, object_path
);
6818 _("A subtree is already exported for %s"),
6823 es
= g_new0 (ExportedSubtree
, 1);
6824 es
->object_path
= g_strdup (object_path
);
6825 es
->connection
= connection
;
6827 es
->vtable
= _g_dbus_subtree_vtable_copy (vtable
);
6829 es
->id
= g_atomic_int_add (&_global_subtree_registration_id
, 1); /* TODO: overflow etc. */
6830 es
->user_data
= user_data
;
6831 es
->user_data_free_func
= user_data_free_func
;
6832 es
->context
= g_main_context_ref_thread_default ();
6834 g_hash_table_insert (connection
->map_object_path_to_es
, es
->object_path
, es
);
6835 g_hash_table_insert (connection
->map_id_to_es
,
6836 GUINT_TO_POINTER (es
->id
),
6842 CONNECTION_UNLOCK (connection
);
6847 /* ---------------------------------------------------------------------------------------------------- */
6850 * g_dbus_connection_unregister_subtree:
6851 * @connection: a #GDBusConnection
6852 * @registration_id: a subtree registration id obtained from
6853 * g_dbus_connection_register_subtree()
6855 * Unregisters a subtree.
6857 * Returns: %TRUE if the subtree was unregistered, %FALSE otherwise
6862 g_dbus_connection_unregister_subtree (GDBusConnection
*connection
,
6863 guint registration_id
)
6865 ExportedSubtree
*es
;
6868 g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection
), FALSE
);
6869 g_return_val_if_fail (check_initialized (connection
), FALSE
);
6873 CONNECTION_LOCK (connection
);
6875 es
= g_hash_table_lookup (connection
->map_id_to_es
,
6876 GUINT_TO_POINTER (registration_id
));
6880 g_warn_if_fail (g_hash_table_remove (connection
->map_id_to_es
, GUINT_TO_POINTER (es
->id
)));
6881 g_warn_if_fail (g_hash_table_remove (connection
->map_object_path_to_es
, es
->object_path
));
6886 CONNECTION_UNLOCK (connection
);
6891 /* ---------------------------------------------------------------------------------------------------- */
6893 /* may be called in any thread, with connection's lock held */
6895 handle_generic_ping_unlocked (GDBusConnection
*connection
,
6896 const gchar
*object_path
,
6897 GDBusMessage
*message
)
6899 GDBusMessage
*reply
;
6900 reply
= g_dbus_message_new_method_reply (message
);
6901 g_dbus_connection_send_message_unlocked (connection
, reply
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, NULL
);
6902 g_object_unref (reply
);
6905 /* may be called in any thread, with connection's lock held */
6907 handle_generic_get_machine_id_unlocked (GDBusConnection
*connection
,
6908 const gchar
*object_path
,
6909 GDBusMessage
*message
)
6911 GDBusMessage
*reply
;
6914 if (connection
->machine_id
== NULL
)
6919 connection
->machine_id
= _g_dbus_get_machine_id (&error
);
6920 if (connection
->machine_id
== NULL
)
6922 reply
= g_dbus_message_new_method_error_literal (message
,
6923 "org.freedesktop.DBus.Error.Failed",
6925 g_error_free (error
);
6931 reply
= g_dbus_message_new_method_reply (message
);
6932 g_dbus_message_set_body (reply
, g_variant_new ("(s)", connection
->machine_id
));
6934 g_dbus_connection_send_message_unlocked (connection
, reply
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, NULL
);
6935 g_object_unref (reply
);
6938 /* may be called in any thread, with connection's lock held */
6940 handle_generic_introspect_unlocked (GDBusConnection
*connection
,
6941 const gchar
*object_path
,
6942 GDBusMessage
*message
)
6947 GDBusMessage
*reply
;
6949 /* first the header */
6950 s
= g_string_new (NULL
);
6951 introspect_append_header (s
);
6953 registered
= g_dbus_connection_list_registered_unlocked (connection
, object_path
);
6954 for (n
= 0; registered
!= NULL
&& registered
[n
] != NULL
; n
++)
6955 g_string_append_printf (s
, " <node name=\"%s\"/>\n", registered
[n
]);
6956 g_strfreev (registered
);
6957 g_string_append (s
, "</node>\n");
6959 reply
= g_dbus_message_new_method_reply (message
);
6960 g_dbus_message_set_body (reply
, g_variant_new ("(s)", s
->str
));
6961 g_dbus_connection_send_message_unlocked (connection
, reply
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, NULL
);
6962 g_object_unref (reply
);
6963 g_string_free (s
, TRUE
);
6966 /* may be called in any thread, with connection's lock held */
6968 handle_generic_unlocked (GDBusConnection
*connection
,
6969 GDBusMessage
*message
)
6972 const gchar
*interface_name
;
6973 const gchar
*member
;
6974 const gchar
*signature
;
6977 CONNECTION_ENSURE_LOCK (connection
);
6981 interface_name
= g_dbus_message_get_interface (message
);
6982 member
= g_dbus_message_get_member (message
);
6983 signature
= g_dbus_message_get_signature (message
);
6984 path
= g_dbus_message_get_path (message
);
6986 if (g_strcmp0 (interface_name
, "org.freedesktop.DBus.Introspectable") == 0 &&
6987 g_strcmp0 (member
, "Introspect") == 0 &&
6988 g_strcmp0 (signature
, "") == 0)
6990 handle_generic_introspect_unlocked (connection
, path
, message
);
6993 else if (g_strcmp0 (interface_name
, "org.freedesktop.DBus.Peer") == 0 &&
6994 g_strcmp0 (member
, "Ping") == 0 &&
6995 g_strcmp0 (signature
, "") == 0)
6997 handle_generic_ping_unlocked (connection
, path
, message
);
7000 else if (g_strcmp0 (interface_name
, "org.freedesktop.DBus.Peer") == 0 &&
7001 g_strcmp0 (member
, "GetMachineId") == 0 &&
7002 g_strcmp0 (signature
, "") == 0)
7004 handle_generic_get_machine_id_unlocked (connection
, path
, message
);
7011 /* ---------------------------------------------------------------------------------------------------- */
7013 /* called in GDBusWorker thread with connection's lock held */
7015 distribute_method_call (GDBusConnection
*connection
,
7016 GDBusMessage
*message
)
7018 GDBusMessage
*reply
;
7020 ExportedSubtree
*es
;
7021 const gchar
*object_path
;
7022 const gchar
*interface_name
;
7023 const gchar
*member
;
7025 gchar
*subtree_path
;
7028 g_assert (g_dbus_message_get_message_type (message
) == G_DBUS_MESSAGE_TYPE_METHOD_CALL
);
7030 interface_name
= g_dbus_message_get_interface (message
);
7031 member
= g_dbus_message_get_member (message
);
7032 path
= g_dbus_message_get_path (message
);
7033 subtree_path
= g_strdup (path
);
7034 needle
= strrchr (subtree_path
, '/');
7035 if (needle
!= NULL
&& needle
!= subtree_path
)
7041 g_free (subtree_path
);
7042 subtree_path
= NULL
;
7046 if (G_UNLIKELY (_g_dbus_debug_incoming ()))
7048 _g_dbus_debug_print_lock ();
7049 g_print ("========================================================================\n"
7050 "GDBus-debug:Incoming:\n"
7051 " <<<< METHOD INVOCATION %s.%s()\n"
7053 " invoked by name %s\n"
7055 interface_name
, member
,
7057 g_dbus_message_get_sender (message
) != NULL
? g_dbus_message_get_sender (message
) : "(none)",
7058 g_dbus_message_get_serial (message
));
7059 _g_dbus_debug_print_unlock ();
7062 object_path
= g_dbus_message_get_path (message
);
7063 g_assert (object_path
!= NULL
);
7065 eo
= g_hash_table_lookup (connection
->map_object_path_to_eo
, object_path
);
7068 if (obj_message_func (connection
, eo
, message
))
7072 es
= g_hash_table_lookup (connection
->map_object_path_to_es
, object_path
);
7075 if (subtree_message_func (connection
, es
, message
))
7079 if (subtree_path
!= NULL
)
7081 es
= g_hash_table_lookup (connection
->map_object_path_to_es
, subtree_path
);
7084 if (subtree_message_func (connection
, es
, message
))
7089 if (handle_generic_unlocked (connection
, message
))
7092 /* if we end up here, the message has not been not handled - so return an error saying this */
7093 reply
= g_dbus_message_new_method_error (message
,
7094 "org.freedesktop.DBus.Error.UnknownMethod",
7095 _("No such interface '%s' on object at path %s"),
7098 g_dbus_connection_send_message_unlocked (connection
, reply
, G_DBUS_SEND_MESSAGE_FLAGS_NONE
, NULL
, NULL
);
7099 g_object_unref (reply
);
7102 g_free (subtree_path
);
7105 /* ---------------------------------------------------------------------------------------------------- */
7107 /* Called in any user thread, with the message_bus_lock held. */
7109 message_bus_get_singleton (GBusType bus_type
,
7113 const gchar
*starter_bus
;
7119 case G_BUS_TYPE_SESSION
:
7120 ret
= &the_session_bus
;
7123 case G_BUS_TYPE_SYSTEM
:
7124 ret
= &the_system_bus
;
7127 case G_BUS_TYPE_STARTER
:
7128 starter_bus
= g_getenv ("DBUS_STARTER_BUS_TYPE");
7129 if (g_strcmp0 (starter_bus
, "session") == 0)
7131 ret
= message_bus_get_singleton (G_BUS_TYPE_SESSION
, error
);
7134 else if (g_strcmp0 (starter_bus
, "system") == 0)
7136 ret
= message_bus_get_singleton (G_BUS_TYPE_SYSTEM
, error
);
7141 if (starter_bus
!= NULL
)
7145 G_IO_ERROR_INVALID_ARGUMENT
,
7146 _("Cannot determine bus address from DBUS_STARTER_BUS_TYPE environment variable"
7147 " - unknown value '%s'"),
7152 g_set_error_literal (error
,
7154 G_IO_ERROR_INVALID_ARGUMENT
,
7155 _("Cannot determine bus address because the DBUS_STARTER_BUS_TYPE environment "
7156 "variable is not set"));
7162 g_assert_not_reached ();
7170 /* Called in any user thread, without holding locks. */
7171 static GDBusConnection
*
7172 get_uninitialized_connection (GBusType bus_type
,
7173 GCancellable
*cancellable
,
7176 GWeakRef
*singleton
;
7177 GDBusConnection
*ret
;
7181 G_LOCK (message_bus_lock
);
7182 singleton
= message_bus_get_singleton (bus_type
, error
);
7183 if (singleton
== NULL
)
7186 ret
= g_weak_ref_get (singleton
);
7191 address
= g_dbus_address_get_for_bus_sync (bus_type
, cancellable
, error
);
7192 if (address
== NULL
)
7194 ret
= g_object_new (G_TYPE_DBUS_CONNECTION
,
7196 "flags", G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT
|
7197 G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION
,
7198 "exit-on-close", TRUE
,
7201 g_weak_ref_set (singleton
, ret
);
7205 g_assert (ret
!= NULL
);
7208 G_UNLOCK (message_bus_lock
);
7212 /* May be called from any thread. Must not hold message_bus_lock. */
7214 _g_bus_get_singleton_if_exists (GBusType bus_type
)
7216 GWeakRef
*singleton
;
7217 GDBusConnection
*ret
= NULL
;
7219 G_LOCK (message_bus_lock
);
7220 singleton
= message_bus_get_singleton (bus_type
, NULL
);
7221 if (singleton
== NULL
)
7224 ret
= g_weak_ref_get (singleton
);
7227 G_UNLOCK (message_bus_lock
);
7233 * @bus_type: a #GBusType
7234 * @cancellable: (nullable): a #GCancellable or %NULL
7235 * @error: return location for error or %NULL
7237 * Synchronously connects to the message bus specified by @bus_type.
7238 * Note that the returned object may shared with other callers,
7239 * e.g. if two separate parts of a process calls this function with
7240 * the same @bus_type, they will share the same object.
7242 * This is a synchronous failable function. See g_bus_get() and
7243 * g_bus_get_finish() for the asynchronous version.
7245 * The returned object is a singleton, that is, shared with other
7246 * callers of g_bus_get() and g_bus_get_sync() for @bus_type. In the
7247 * event that you need a private message bus connection, use
7248 * g_dbus_address_get_for_bus_sync() and
7249 * g_dbus_connection_new_for_address().
7251 * Note that the returned #GDBusConnection object will (usually) have
7252 * the #GDBusConnection:exit-on-close property set to %TRUE.
7254 * Returns: (transfer full): a #GDBusConnection or %NULL if @error is set.
7255 * Free with g_object_unref().
7260 g_bus_get_sync (GBusType bus_type
,
7261 GCancellable
*cancellable
,
7264 GDBusConnection
*connection
;
7266 _g_dbus_initialize ();
7268 g_return_val_if_fail (error
== NULL
|| *error
== NULL
, NULL
);
7270 connection
= get_uninitialized_connection (bus_type
, cancellable
, error
);
7271 if (connection
== NULL
)
7274 if (!g_initable_init (G_INITABLE (connection
), cancellable
, error
))
7276 g_object_unref (connection
);
7285 bus_get_async_initable_cb (GObject
*source_object
,
7289 GTask
*task
= user_data
;
7290 GError
*error
= NULL
;
7292 if (!g_async_initable_init_finish (G_ASYNC_INITABLE (source_object
),
7296 g_assert (error
!= NULL
);
7297 g_task_return_error (task
, error
);
7298 g_object_unref (source_object
);
7302 g_task_return_pointer (task
, source_object
, g_object_unref
);
7304 g_object_unref (task
);
7309 * @bus_type: a #GBusType
7310 * @cancellable: (nullable): a #GCancellable or %NULL
7311 * @callback: a #GAsyncReadyCallback to call when the request is satisfied
7312 * @user_data: the data to pass to @callback
7314 * Asynchronously connects to the message bus specified by @bus_type.
7316 * When the operation is finished, @callback will be invoked. You can
7317 * then call g_bus_get_finish() to get the result of the operation.
7319 * This is a asynchronous failable function. See g_bus_get_sync() for
7320 * the synchronous version.
7325 g_bus_get (GBusType bus_type
,
7326 GCancellable
*cancellable
,
7327 GAsyncReadyCallback callback
,
7330 GDBusConnection
*connection
;
7332 GError
*error
= NULL
;
7334 _g_dbus_initialize ();
7336 task
= g_task_new (NULL
, cancellable
, callback
, user_data
);
7337 g_task_set_source_tag (task
, g_bus_get
);
7339 connection
= get_uninitialized_connection (bus_type
, cancellable
, &error
);
7340 if (connection
== NULL
)
7342 g_assert (error
!= NULL
);
7343 g_task_return_error (task
, error
);
7344 g_object_unref (task
);
7348 g_async_initable_init_async (G_ASYNC_INITABLE (connection
),
7351 bus_get_async_initable_cb
,
7358 * @res: a #GAsyncResult obtained from the #GAsyncReadyCallback passed
7360 * @error: return location for error or %NULL
7362 * Finishes an operation started with g_bus_get().
7364 * The returned object is a singleton, that is, shared with other
7365 * callers of g_bus_get() and g_bus_get_sync() for @bus_type. In the
7366 * event that you need a private message bus connection, use
7367 * g_dbus_address_get_for_bus_sync() and
7368 * g_dbus_connection_new_for_address().
7370 * Note that the returned #GDBusConnection object will (usually) have
7371 * the #GDBusConnection:exit-on-close property set to %TRUE.
7373 * Returns: (transfer full): a #GDBusConnection or %NULL if @error is set.
7374 * Free with g_object_unref().
7379 g_bus_get_finish (GAsyncResult
*res
,
7382 g_return_val_if_fail (g_task_is_valid (res
, NULL
), NULL
);
7383 g_return_val_if_fail (error
== NULL
|| *error
== NULL
, NULL
);
7385 return g_task_propagate_pointer (G_TASK (res
), error
);
7388 /* ---------------------------------------------------------------------------------------------------- */