X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gio%2Fgdbusconnection.c;h=ca09ae3ae568dba233019db04d9750abb3df454f;hb=2a53b4d0e2c98a14aedf31e38f0ad1fb2e8fe26f;hp=5969a01a7c50710cccd467ca4e5af7ea7e3ab286;hpb=8792609e15394967cab526838b83f90acb401663;p=platform%2Fupstream%2Fglib.git diff --git a/gio/gdbusconnection.c b/gio/gdbusconnection.c index 5969a01..ca09ae3 100644 --- a/gio/gdbusconnection.c +++ b/gio/gdbusconnection.c @@ -122,6 +122,7 @@ #include "gsimpleasyncresult.h" #ifdef G_OS_UNIX +#include "gkdbus.h" #include "gunixconnection.h" #include "gunixfdmessage.h" #endif @@ -139,7 +140,7 @@ * over any transport that can by represented as an #GIOStream. * * This class is rarely used directly in D-Bus clients. If you are writing - * an D-Bus client, it is often easier to use the g_bus_own_name(), + * a D-Bus client, it is often easier to use the g_bus_own_name(), * g_bus_watch_name() or g_dbus_proxy_new_for_bus() APIs. * * As an exception to the usual GLib rule that a particular object must not @@ -212,6 +213,8 @@ G_LOCK_DEFINE_STATIC (message_bus_lock); static GWeakRef the_session_bus; static GWeakRef the_system_bus; +static GWeakRef the_user_bus; +static GWeakRef the_machine_bus; /* Extra pseudo-member of GDBusSendMessageFlags. * Set by initable_init() to indicate that despite not being initialized yet, @@ -387,6 +390,7 @@ struct _GDBusConnection * hold @init_lock or check for initialization first. */ GDBusWorker *worker; + GKDBusWorker *kdbus_worker; /* If connected to a message bus, this contains the unique name assigned to * us by the bus (e.g. ":1.42"). @@ -1158,8 +1162,12 @@ g_dbus_connection_start_message_processing (GDBusConnection *connection) if (!check_initialized (connection)) return; - g_assert (connection->worker != NULL); - _g_dbus_worker_unfreeze (connection->worker); + g_assert (connection->worker || connection->kdbus_worker); + + if (connection->kdbus_worker) + g_kdbus_worker_unfreeze (connection->kdbus_worker); + else + _g_dbus_worker_unfreeze (connection->worker); } /** @@ -1591,6 +1599,468 @@ g_dbus_connection_close_sync (GDBusConnection *connection, /* ---------------------------------------------------------------------------------------------------- */ /** + * g_dbus_request_name: + * @connection: a #GDBusConnection + * @name: well-known bus name (name to request) + * @flags: a set of flags from the GBusNameOwnerFlags enumeration + * @error: return location for error or %NULL + * + * Synchronously acquires name on the bus and returns status code. + * + * The calling thread is blocked until a reply is received. + * + * Returns: status code or %G_BUS_REQUEST_NAME_FLAGS_ERROR + * if @error is set. + * + * Since: 2.4x + */ +GBusRequestNameReplyFlags +g_dbus_request_name (GDBusConnection *connection, + const gchar *name, + GBusNameOwnerFlags flags, + GError **error) +{ + GVariant *result; + guint32 request_name_reply; + + g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), G_BUS_RELEASE_NAME_FLAGS_ERROR); + g_return_val_if_fail (g_dbus_is_name (name) && !g_dbus_is_unique_name (name), G_BUS_RELEASE_NAME_FLAGS_ERROR); + g_return_val_if_fail (error == NULL || *error == NULL, G_BUS_RELEASE_NAME_FLAGS_ERROR); + + if (connection->kdbus_worker) + result = _g_kdbus_RequestName (connection->kdbus_worker, name, flags, error); + else + result = g_dbus_connection_call_sync (connection, "org.freedesktop.DBus", "/org/freedesktop/DBus", + "org.freedesktop.DBus", "RequestName", + g_variant_new ("(su)", name, flags), G_VARIANT_TYPE ("(u)"), + G_DBUS_CALL_FLAGS_NONE, -1, NULL, error); + + if (result != NULL) + { + g_variant_get (result, "(u)", &request_name_reply); + g_variant_unref (result); + } + else + request_name_reply = G_BUS_REQUEST_NAME_FLAGS_ERROR; + + return (GBusRequestNameReplyFlags) request_name_reply; +} + +/** + * g_dbus_release_name: + * @connection: a #GDBusConnection + * @name: well-known bus name (name to release) + * @error: return location for error or %NULL + * + * Synchronously releases name on the bus and returns status code. + * + * The calling thread is blocked until a reply is received. + * + * Returns: status code or %G_BUS_RELEASE_NAME_FLAGS_ERROR + * if @error is set. + * + * Since: 2.4x + */ +GBusReleaseNameReplyFlags +g_dbus_release_name (GDBusConnection *connection, + const gchar *name, + GError **error) +{ + GVariant *result; + guint32 release_name_reply; + + g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), G_BUS_RELEASE_NAME_FLAGS_ERROR); + g_return_val_if_fail (g_dbus_is_name (name) && !g_dbus_is_unique_name (name), G_BUS_RELEASE_NAME_FLAGS_ERROR); + g_return_val_if_fail (error == NULL || *error == NULL, G_BUS_RELEASE_NAME_FLAGS_ERROR); + + if (connection->kdbus_worker) + result = _g_kdbus_ReleaseName (connection->kdbus_worker, name, error); + else + result = g_dbus_connection_call_sync (connection, "org.freedesktop.DBus", "/org/freedesktop/DBus", + "org.freedesktop.DBus", "ReleaseName", + g_variant_new ("(s)", name), G_VARIANT_TYPE ("(u)"), + G_DBUS_CALL_FLAGS_NONE, -1, NULL, error); + + if (result != NULL) + { + g_variant_get (result, "(u)", &release_name_reply); + g_variant_unref (result); + } + else + release_name_reply = G_BUS_RELEASE_NAME_FLAGS_ERROR; + + return (GBusReleaseNameReplyFlags) release_name_reply; +} + +/** + * g_dbus_get_bus_id: + * @connection: a #GDBusConnection + * @error: return location for error or %NULL + * + * Synchronously returns the unique ID of the bus. + * + * The calling thread is blocked until a reply is received. + * + * Returns: the unique ID of the bus or %NULL if @error is set. + * Free with g_free(). + * + * Since: 2.4x + */ +gchar * +g_dbus_get_bus_id (GDBusConnection *connection, + GError **error) +{ + GVariant *result; + gchar *bus_id; + + g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), NULL); + g_return_val_if_fail (error == NULL || *error == NULL, NULL); + + result = NULL; + bus_id = NULL; + + if (connection->kdbus_worker) + { + result = _g_kdbus_GetBusId (connection->kdbus_worker, error); + } + else + { + result = g_dbus_connection_call_sync (connection, "org.freedesktop.DBus", "/", + "org.freedesktop.DBus", "GetId", + NULL, G_VARIANT_TYPE ("(s)"), + G_DBUS_CALL_FLAGS_NONE, -1, NULL, error); + } + + if (result != NULL) + { + g_variant_get (result, "(s)", &bus_id); + g_variant_unref (result); + } + + return bus_id; +} + +typedef enum +{ + LIST_NAMES, + LIST_ACTIVATABLE_NAMES, + LIST_QUEUED_OWNERS +} GDBusListNameType; + +static gchar ** +_g_dbus_get_list_internal (GDBusConnection *connection, + const gchar *name, + GDBusListNameType list_name_type, + GError **error) +{ + gchar **strv; + GVariant *result; + GVariantIter *iter; + gchar *str; + gsize n, i; + + result = NULL; + strv = NULL; + + if (list_name_type == LIST_QUEUED_OWNERS) + { + if (connection->kdbus_worker) + result = _g_kdbus_GetListQueuedOwners (connection->kdbus_worker, name, error); + else + result = g_dbus_connection_call_sync (connection, "org.freedesktop.DBus", "/", + "org.freedesktop.DBus", "ListQueuedOwners", + g_variant_new ("(s)", name), G_VARIANT_TYPE ("(as)"), + G_DBUS_CALL_FLAGS_NONE, -1, NULL, error); + } + else + { + gchar *method_name; + + if (list_name_type == LIST_NAMES) + method_name = "ListNames"; + else + method_name = "ListActivatableNames"; + + if (connection->kdbus_worker) + result = _g_kdbus_GetListNames (connection->kdbus_worker, list_name_type, error); + else + result = g_dbus_connection_call_sync (connection, "org.freedesktop.DBus", "/", + "org.freedesktop.DBus", method_name, + NULL, G_VARIANT_TYPE ("(as)"), + G_DBUS_CALL_FLAGS_NONE, -1, NULL, error); + } + + if (result != NULL) + { + g_variant_get (result, "(as)", &iter); + n = g_variant_iter_n_children (iter); + strv = g_new (gchar *, n + 1); + + i = 0; + while (g_variant_iter_loop (iter, "s", &str)) + { + strv[i] = g_strdup (str); + i++; + } + strv[i] = NULL; + + g_variant_iter_free (iter); + g_variant_unref (result); + } + + return strv; +} + +/** + * g_dbus_get_list_names: + * @connection: a #GDBusConnection + * @error: return location for error or %NULL + * + * Synchronously returns a list of all currently-owned names on the bus. + * + * The calling thread is blocked until a reply is received. + * + * Returns: a list of all currently-owned names on the bus or %NULL if + * @error is set. Free with g_strfreev(). + * + * Since: 2.4x + */ +gchar ** +g_dbus_get_list_names (GDBusConnection *connection, + GError **error) +{ + gchar **strv; + + g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), NULL); + g_return_val_if_fail (error == NULL || *error == NULL, NULL); + + strv = _g_dbus_get_list_internal (connection, NULL, LIST_NAMES, error); + + return strv; +} + +/** + * g_dbus_get_list_activatable_names: + * @connection: a #GDBusConnection + * @error: return location for error or %NULL + * + * Synchronously returns a list of all names that can be activated on the bus. + * + * The calling thread is blocked until a reply is received. + * + * Returns: a list of all names that can be activated on the bus or %NULL if + * @error is set. Free with g_strfreev(). + * + * Since: 2.4x + */ +gchar ** +g_dbus_get_list_activatable_names (GDBusConnection *connection, + GError **error) +{ + gchar **strv; + + g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), NULL); + g_return_val_if_fail (error == NULL || *error == NULL, NULL); + + strv = _g_dbus_get_list_internal (connection, NULL, LIST_ACTIVATABLE_NAMES, error); + + return strv; +} + +/** + * g_dbus_get_list_queued_names: + * @connection: a #GDBusConnection + * @name: a unique or well-known bus name + * @error: return location for error or %NULL + * + * Synchronously returns the unique bus names of connections currently queued + * for the @name. + * + * If @name contains a value not compatible with the D-Bus syntax and naming + * conventions for bus names, the operation returns %NULL and @error is set. + * + * The calling thread is blocked until a reply is received. + * + * Returns: the unique bus names of connections currently queued for the @name + * or %NULL if @error is set. Free with g_strfreev(). + * + * Since: 2.4x + */ +gchar ** +g_dbus_get_list_queued_owners (GDBusConnection *connection, + const gchar *name, + GError **error) +{ + gchar **strv; + + g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), NULL); + g_return_val_if_fail (name == NULL || g_dbus_is_name (name), NULL); + g_return_val_if_fail (error == NULL || *error == NULL, NULL); + + strv = _g_dbus_get_list_internal (connection, name, LIST_QUEUED_OWNERS, error); + + return strv; +} + +/** + * g_dbus_get_name_owner: + * @connection: a #GDBusConnection + * @name: well-known bus name to get the owner of + * @error: return location for error or %NULL + * + * Synchronously returns the unique connection name of the primary owner of + * the name given. If the requested name doesn't have an owner, an @error is + * returned. + * + * If @name contains a value not compatible with the D-Bus syntax and naming + * conventions for bus names, the operation returns %NULL and @error is set. + * + * The calling thread is blocked until a reply is received. + * + * Returns: the unique connection name of the primary owner of the + * name given. If the requested name doesn't have an owner, function + * returns %NULL and @error is set. Free with g_free(). + * + * Since: 2.4x + */ +gchar * +g_dbus_get_name_owner (GDBusConnection *connection, + const gchar *name, + GError **error) +{ + GVariant *result; + gchar *name_owner; + + g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), NULL); + g_return_val_if_fail (name == NULL || g_dbus_is_name (name), NULL); + g_return_val_if_fail (error == NULL || *error == NULL, NULL); + + name_owner = NULL; + result = NULL; + + if (connection->kdbus_worker) + result = _g_kdbus_GetNameOwner (connection->kdbus_worker, name, error); + else + result = g_dbus_connection_call_sync (connection, "org.freedesktop.DBus", "/", + "org.freedesktop.DBus", "GetNameOwner", + g_variant_new ("(s)", name), G_VARIANT_TYPE ("(s)"), + G_DBUS_CALL_FLAGS_NONE, -1, NULL, error); + if (result != NULL) + { + g_variant_get (result, "(s)", &name_owner); + g_variant_unref (result); + } + else + name_owner = NULL; + + return name_owner; +} + +/** + * g_dbus_get_connection_pid: + * @connection: a #GDBusConnection + * @name: a unique or well-known bus name of the connection to query + * @error: return location for error or %NULL + * + * Synchronously returns the Unix process ID of the process connected to the + * bus. If unable to determine it, an @error is returned. + * + * If @name contains a value not compatible with the D-Bus syntax and naming + * conventions for bus names, the operation returns (guint32) -1 and @error + * is set. + * + * The calling thread is blocked until a reply is received. + * + * Returns: the Unix process ID of the process connected to the bus or + * (guint32) -1 if @error is set. + * + * Since: 2.4x + */ +guint32 +g_dbus_get_connection_pid (GDBusConnection *connection, + const gchar *name, + GError **error) +{ + GVariant *result; + guint32 pid; + + g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), -1); + g_return_val_if_fail (name == NULL || g_dbus_is_name (name), -1); + g_return_val_if_fail (error == NULL || *error == NULL, -1); + + result = NULL; + pid = -1; + + if (connection->kdbus_worker) + result = _g_kdbus_GetConnectionUnixProcessID (connection->kdbus_worker, name, error); + else + result = g_dbus_connection_call_sync (connection, "org.freedesktop.DBus", "/", + "org.freedesktop.DBus", "GetConnectionUnixProcessID", + g_variant_new ("(s)", name), G_VARIANT_TYPE ("(u)"), + G_DBUS_CALL_FLAGS_NONE, -1, NULL, error); + if (result != NULL) + { + g_variant_get (result, "(u)", &pid); + g_variant_unref (result); + } + + return pid; +} + +/** + * g_dbus_get_connection_uid: + * @connection: a #GDBusConnection + * @name: a unique or well-known bus name of the connection to query + * @error: return location for error or %NULL + * + * Synchronously returns the Unix user ID of the process connected to the + * bus. If unable to determine it, an @error is returned. + * + * If @name contains a value not compatible with the D-Bus syntax and naming + * conventions for bus names, the operation returns (guint32) -1 and @error + * is set. + * + * The calling thread is blocked until a reply is received. + * + * Returns: the Unix user ID of the process connected to the bus or + * (guint32) -1 if @error is set. + * + * Since: 2.4x + */ +guint32 +g_dbus_get_connection_uid (GDBusConnection *connection, + const gchar *name, + GError **error) +{ + GVariant *result; + guint32 uid; + + g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), -1); + g_return_val_if_fail (name == NULL || g_dbus_is_name (name), -1); + g_return_val_if_fail (error == NULL || *error == NULL, -1); + + result = NULL; + uid = -1; + + if (connection->kdbus_worker) + result = _g_kdbus_GetConnectionUnixUser (connection->kdbus_worker, name, error); + else + result = g_dbus_connection_call_sync (connection, "org.freedesktop.DBus", "/", + "org.freedesktop.DBus", "GetConnectionUnixUser", + g_variant_new ("(s)", name), G_VARIANT_TYPE ("(u)"), + G_DBUS_CALL_FLAGS_NONE, -1, NULL, error); + if (result != NULL) + { + g_variant_get (result, "(u)", &uid); + g_variant_unref (result); + } + + return uid; +} + +/* ---------------------------------------------------------------------------------------------------- */ + +/** * g_dbus_connection_get_last_serial: * @connection: a #GDBusConnection * @@ -1621,7 +2091,7 @@ g_dbus_connection_get_last_serial (GDBusConnection *connection) } /* ---------------------------------------------------------------------------------------------------- */ - +#include "gkdbus.h" /* Can be called by any thread, with the connection lock held */ static gboolean g_dbus_connection_send_message_unlocked (GDBusConnection *connection, @@ -1662,13 +2132,16 @@ g_dbus_connection_send_message_unlocked (GDBusConnection *connection, &blob_size, connection->capabilities, error); + if (blob == NULL) goto out; - if (flags & G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL) - serial_to_use = g_dbus_message_get_serial (message); - else - serial_to_use = ++connection->last_serial; /* TODO: handle overflow */ + if (!(flags & G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL)) + g_dbus_message_set_serial (message, ++connection->last_serial); + + serial_to_use = g_dbus_message_get_serial (message); + + g_dbus_message_lock (message); switch (blob[0]) { @@ -1705,14 +2178,14 @@ g_dbus_connection_send_message_unlocked (GDBusConnection *connection, g_thread_self (), GUINT_TO_POINTER (serial_to_use)); - if (!(flags & G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL)) - g_dbus_message_set_serial (message, serial_to_use); - - g_dbus_message_lock (message); + if (connection->worker) _g_dbus_worker_send_message (connection->worker, message, (gchar*) blob, blob_size); + else + g_kdbus_worker_send_message (connection->kdbus_worker, message, error); + blob = NULL; /* since _g_dbus_worker_send_message() steals the blob */ ret = TRUE; @@ -2285,8 +2758,7 @@ typedef struct /* Called in GDBusWorker's thread - we must not block - with no lock held */ static void -on_worker_message_received (GDBusWorker *worker, - GDBusMessage *message, +on_worker_message_received (GDBusMessage *message, gpointer user_data) { GDBusConnection *connection; @@ -2387,8 +2859,7 @@ on_worker_message_received (GDBusWorker *worker, /* Called in GDBusWorker's thread, lock is not held */ static GDBusMessage * -on_worker_message_about_to_be_sent (GDBusWorker *worker, - GDBusMessage *message, +on_worker_message_about_to_be_sent (GDBusMessage *message, gpointer user_data) { GDBusConnection *connection; @@ -2464,10 +2935,9 @@ cancel_method_on_close (gpointer key, gpointer value, gpointer user_data) /* Called in GDBusWorker's thread - we must not block - without lock held */ static void -on_worker_closed (GDBusWorker *worker, - gboolean remote_peer_vanished, - GError *error, - gpointer user_data) +on_worker_closed (gboolean remote_peer_vanished, + GError *error, + gpointer user_data) { GDBusConnection *connection; gboolean alive; @@ -2529,6 +2999,7 @@ initable_init (GInitable *initable, GError **error) { GDBusConnection *connection = G_DBUS_CONNECTION (initable); + gboolean initially_frozen; gboolean ret; /* This method needs to be idempotent to work with the singleton @@ -2566,6 +3037,8 @@ initable_init (GInitable *initable, */ if (connection->address != NULL) { + GObject *ret; + g_assert (connection->stream == NULL); if ((connection->flags & G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER) || @@ -2578,12 +3051,18 @@ initable_init (GInitable *initable, goto out; } - connection->stream = g_dbus_address_get_stream_sync (connection->address, - NULL, /* TODO: out_guid */ - cancellable, - &connection->initialization_error); - if (connection->stream == NULL) + ret = g_dbus_address_get_stream_internal (connection->address, TRUE, + NULL, /* TODO: out_guid */ + cancellable, &connection->initialization_error); + if (ret == NULL) goto out; + + if (G_IS_IO_STREAM (ret)) + connection->stream = G_IO_STREAM (ret); + else if (G_IS_KDBUS_WORKER (ret)) + connection->kdbus_worker = G_KDBUS_WORKER (ret); + else + g_assert_not_reached (); } else if (connection->stream != NULL) { @@ -2594,6 +3073,12 @@ initable_init (GInitable *initable, g_assert_not_reached (); } + /* [KDBUS] Skip authentication process for kdbus transport */ + if (connection->kdbus_worker) + { + goto authenticated; + } + /* Authenticate the connection */ if (connection->flags & G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER) { @@ -2632,6 +3117,8 @@ initable_init (GInitable *initable, connection->authentication_observer = NULL; } +authenticated: + //g_output_stream_flush (G_SOCKET_CONNECTION (connection->stream) //g_debug ("haz unix fd passing powers: %d", connection->capabilities & G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING); @@ -2652,13 +3139,23 @@ initable_init (GInitable *initable, g_hash_table_insert (alive_connections, connection, connection); G_UNLOCK (message_bus_lock); - connection->worker = _g_dbus_worker_new (connection->stream, - connection->capabilities, - ((connection->flags & G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING) != 0), - on_worker_message_received, - on_worker_message_about_to_be_sent, - on_worker_closed, - connection); + initially_frozen = (connection->flags & G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING) != 0; + + if (connection->kdbus_worker) + g_kdbus_worker_associate (connection->kdbus_worker, + connection->capabilities, + on_worker_message_received, + on_worker_message_about_to_be_sent, + on_worker_closed, + connection); + else + connection->worker = _g_dbus_worker_new (connection->stream, + connection->capabilities, + initially_frozen, + on_worker_message_received, + on_worker_message_about_to_be_sent, + on_worker_closed, + connection); /* if a bus connection, call org.freedesktop.DBus.Hello - this is how we're getting a name */ if (connection->flags & G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION) @@ -2675,17 +3172,25 @@ initable_init (GInitable *initable, goto out; } - hello_result = g_dbus_connection_call_sync (connection, - "org.freedesktop.DBus", /* name */ - "/org/freedesktop/DBus", /* path */ - "org.freedesktop.DBus", /* interface */ - "Hello", - NULL, /* parameters */ - G_VARIANT_TYPE ("(s)"), - CALL_FLAGS_INITIALIZING, - -1, - NULL, /* TODO: cancellable */ - &connection->initialization_error); + if (connection->kdbus_worker) + { + hello_result = _g_kdbus_Hello (connection->kdbus_worker, &connection->initialization_error); + } + else + { + hello_result = g_dbus_connection_call_sync (connection, + "org.freedesktop.DBus", /* name */ + "/org/freedesktop/DBus", /* path */ + "org.freedesktop.DBus", /* interface */ + "Hello", + NULL, /* parameters */ + G_VARIANT_TYPE ("(s)"), + CALL_FLAGS_INITIALIZING, + -1, + NULL, /* TODO: cancellable */ + &connection->initialization_error); + } + if (hello_result == NULL) goto out; @@ -2694,6 +3199,9 @@ initable_init (GInitable *initable, //g_debug ("unique name is '%s'", connection->bus_unique_name); } + if (connection->kdbus_worker && !initially_frozen) + g_kdbus_worker_unfreeze (connection->kdbus_worker); + ret = TRUE; out: if (!ret) @@ -3550,7 +4058,20 @@ g_dbus_connection_signal_subscribe (GDBusConnection *connection, if (connection->flags & G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION) { if (!is_signal_data_for_name_lost_or_acquired (signal_data)) - add_match_rule (connection, signal_data->rule); + if (connection->kdbus_worker) + _g_kdbus_AddMatch (connection->kdbus_worker, signal_data->rule, subscriber.id); + else + add_match_rule (connection, signal_data->rule); + else + { + if (connection->kdbus_worker) + { + if (g_strcmp0 (signal_data->member, "NameAcquired") == 0) + _g_kdbus_subscribe_name_acquired (connection->kdbus_worker, arg0); + else if (g_strcmp0 (signal_data->member, "NameLost") == 0) + _g_kdbus_subscribe_name_lost (connection->kdbus_worker, arg0); + } + } } signal_data_array = g_hash_table_lookup (connection->map_sender_unique_name_to_signal_data_array, @@ -3635,7 +4156,20 @@ unsubscribe_id_internal (GDBusConnection *connection, * so on_worker_closed() can't happen between the check we just * did, and releasing the lock later. */ - remove_match_rule (connection, signal_data->rule); + if (connection->kdbus_worker) + _g_kdbus_RemoveMatch (connection->kdbus_worker, subscription_id); + else + remove_match_rule (connection, signal_data->rule); + } + else + { + if (connection->kdbus_worker) + { + if (g_strcmp0 (signal_data->member, "NameAcquired") == 0) + _g_kdbus_unsubscribe_name_acquired (connection->kdbus_worker); + else if (g_strcmp0 (signal_data->member, "NameLost") == 0) + _g_kdbus_unsubscribe_name_lost (connection->kdbus_worker); + } } signal_data_free (signal_data); @@ -3728,7 +4262,7 @@ emit_signal_instance_in_idle_cb (gpointer data) } else { - g_variant_ref_sink (parameters); + g_variant_ref (parameters); } #if 0 @@ -6909,6 +7443,14 @@ message_bus_get_singleton (GBusType bus_type, ret = &the_system_bus; break; + case G_BUS_TYPE_USER: + ret = &the_user_bus; + break; + + case G_BUS_TYPE_MACHINE: + ret = &the_machine_bus; + break; + case G_BUS_TYPE_STARTER: starter_bus = g_getenv ("DBUS_STARTER_BUS_TYPE"); if (g_strcmp0 (starter_bus, "session") == 0)