X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gio%2Fgdbusconnection.c;h=680062e951f1863be461425a7e0e1c82d455eaec;hb=3389489f0f25a3a324ad62d9df5a6f1c038d5986;hp=5969a01a7c50710cccd467ca4e5af7ea7e3ab286;hpb=8792609e15394967cab526838b83f90acb401663;p=platform%2Fupstream%2Fglib.git diff --git a/gio/gdbusconnection.c b/gio/gdbusconnection.c index 5969a01..680062e 100644 --- a/gio/gdbusconnection.c +++ b/gio/gdbusconnection.c @@ -122,6 +122,8 @@ #include "gsimpleasyncresult.h" #ifdef G_OS_UNIX +#include "gkdbus.h" +#include "gkdbusconnection.h" #include "gunixconnection.h" #include "gunixfdmessage.h" #endif @@ -139,7 +141,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 +214,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, @@ -1591,6 +1595,519 @@ 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 (G_IS_KDBUS_CONNECTION (connection->stream)) + result = _g_kdbus_RequestName (connection, 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 (G_IS_KDBUS_CONNECTION (connection->stream)) + result = _g_kdbus_ReleaseName (connection, 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 (G_IS_KDBUS_CONNECTION (connection->stream)) + { + result = _g_kdbus_GetBusId (connection, 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 (G_IS_KDBUS_CONNECTION (connection->stream)) + result = _g_kdbus_GetListQueuedOwners (connection, 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 (G_IS_KDBUS_CONNECTION (connection->stream)) + result = _g_kdbus_GetListNames (connection, 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 (G_IS_KDBUS_CONNECTION (connection->stream)) + result = _g_kdbus_GetNameOwner (connection, 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_name_has_owner: + * @connection: a #GDBusConnection + * @name: a unique or well-known bus name + * @error: return location for error or %NULL + * + * Synchronously checks if the specified name exists (currently has an owner). + * + * 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: %TRUE if specified name exists (currently has an owner) + * If the requested name doesn't have an owner or @error is set, + * function returns %FALSE. + * + * Since: 2.4x + */ +gboolean +g_dbus_name_has_owner (GDBusConnection *connection, + const gchar *name, + GError **error) +{ + GVariant *result; + gboolean ret; + + 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); + + result = NULL; + + if (G_IS_KDBUS_CONNECTION (connection->stream)) + result = _g_kdbus_NameHasOwner (connection, name, error); + else + result = g_dbus_connection_call_sync (connection, "org.freedesktop.DBus", "/", + "org.freedesktop.DBus", "NameHasOwner", + g_variant_new ("(s)", name), G_VARIANT_TYPE ("(b)"), + G_DBUS_CALL_FLAGS_NONE, -1, NULL, error); + if (result != NULL) + { + g_variant_get (result, "(b)", &ret); + g_variant_unref (result); + } + else + ret = FALSE; + + return ret; +} + +/** + * 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 (G_IS_KDBUS_CONNECTION (connection->stream)) + result = _g_kdbus_GetConnectionUnixProcessID (connection, 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 (G_IS_KDBUS_CONNECTION (connection->stream)) + result = _g_kdbus_GetConnectionUnixUser (connection, 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 * @@ -2594,6 +3111,12 @@ initable_init (GInitable *initable, g_assert_not_reached (); } + /* [KDBUS] Skip authentication process for kdbus transport */ + if (G_IS_KDBUS_CONNECTION (connection->stream)) + { + goto authenticated; + } + /* Authenticate the connection */ if (connection->flags & G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER) { @@ -2632,6 +3155,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); @@ -2675,17 +3200,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 (G_IS_KDBUS_CONNECTION (connection->stream)) + { + hello_result = _g_kdbus_Hello (connection->stream, &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; @@ -3551,6 +4084,16 @@ g_dbus_connection_signal_subscribe (GDBusConnection *connection, { if (!is_signal_data_for_name_lost_or_acquired (signal_data)) add_match_rule (connection, signal_data->rule); + else + { + if (G_IS_KDBUS_CONNECTION (connection->stream)) + { + if (g_strcmp0 (signal_data->member, "NameAcquired") == 0) + _g_kdbus_subscribe_name_acquired (connection, arg0); + else if (g_strcmp0 (signal_data->member, "NameLost") == 0) + _g_kdbus_subscribe_name_lost (connection, arg0); + } + } } signal_data_array = g_hash_table_lookup (connection->map_sender_unique_name_to_signal_data_array, @@ -3637,6 +4180,13 @@ unsubscribe_id_internal (GDBusConnection *connection, */ remove_match_rule (connection, signal_data->rule); } + else + { + if (G_IS_KDBUS_CONNECTION (connection->stream)) + { + //_g_kdbus_unsubscribe_name_lost_and_acquired (connection, arg0); + } + } signal_data_free (signal_data); } @@ -3728,7 +4278,7 @@ emit_signal_instance_in_idle_cb (gpointer data) } else { - g_variant_ref_sink (parameters); + g_variant_ref (parameters); } #if 0 @@ -6909,6 +7459,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)