summaryrefslogtreecommitdiff
path: root/libgdm
diff options
context:
space:
mode:
authorRay Strode <rstrode@redhat.com>2013-12-16 10:52:34 -0500
committerRay Strode <rstrode@redhat.com>2013-12-16 11:58:10 -0500
commitaf4e5855a22af0774f734b2b86ce7afc0a84e6e1 (patch)
tree56898960da24bee90ad13efef3936f8f593e37e6 /libgdm
parentf71f8d1e2a4a29643f7e1559aaece750af5326fe (diff)
downloadgdm-af4e5855a22af0774f734b2b86ce7afc0a84e6e1.tar.gz
libgdm: move out of gui/ directory
libgdm isn't a UI, so it's weird to be in a directory called GUI. This commit moves it up a layer.
Diffstat (limited to 'libgdm')
-rw-r--r--libgdm/Makefile.am121
-rw-r--r--libgdm/gdm-client.c1445
-rw-r--r--libgdm/gdm-client.h123
-rw-r--r--libgdm/gdm-sessions.c280
-rw-r--r--libgdm/gdm-sessions.h37
-rw-r--r--libgdm/gdm-user-switching.c597
-rw-r--r--libgdm/gdm-user-switching.h31
-rw-r--r--libgdm/gdm.pc.in10
8 files changed, 2644 insertions, 0 deletions
diff --git a/libgdm/Makefile.am b/libgdm/Makefile.am
new file mode 100644
index 00000000..99ada9aa
--- /dev/null
+++ b/libgdm/Makefile.am
@@ -0,0 +1,121 @@
+END_OF_LIST =
+
+BUILT_SOURCES = gdm-manager-glue.h gdm-client-glue.h
+CLEANFILES = \
+ $(BUILT_SOURCES) \
+ gdm-manager-glue.c \
+ gdm-client-glue.c \
+ $(END_OF_LIST)
+
+gdm-manager-glue.c gdm-manager-glue.h : $(top_srcdir)/daemon/gdm-manager.xml Makefile.am
+ $(AM_V_GEN)gdbus-codegen \
+ --c-namespace Gdm \
+ --interface-prefix=org.gnome.DisplayManager \
+ --generate-c-code=gdm-manager-glue \
+ --annotate "org.gnome.DisplayManager.Manager" \
+ "org.gtk.GDBus.C.Name" Manager \
+ $(top_srcdir)/daemon/gdm-manager.xml
+
+gdm-client-glue.c gdm-client-glue.h : $(top_srcdir)/daemon/gdm-session.xml Makefile.am
+ $(AM_V_GEN)gdbus-codegen \
+ --c-namespace Gdm \
+ --interface-prefix=org.gnome.DisplayManager \
+ --generate-c-code=gdm-client-glue \
+ --annotate "org.gnome.DisplayManager.UserVerifier" \
+ "org.gtk.GDBus.C.Name" UserVerifier \
+ --annotate "org.gnome.DisplayManager.Greeter" \
+ "org.gtk.GDBus.C.Name" Greeter \
+ --annotate "org.gnome.DisplayManager.RemoteGreeter" \
+ "org.gtk.GDBus.C.Name" RemoteGreeter \
+ --annotate "org.gnome.DisplayManager.Chooser" \
+ "org.gtk.GDBus.C.Name" Chooser \
+ $(top_srcdir)/daemon/gdm-session.xml
+
+AM_CPPFLAGS = \
+ -I$(srcdir) \
+ -I$(builddir) \
+ -I$(top_srcdir) \
+ -I$(top_builddir) \
+ -DG_LOG_DOMAIN=\"Gdm\" \
+ -DDMCONFDIR=\""$(dmconfdir)"\" \
+ -DDATADIR=\""$(datadir)"\" \
+ $(END_OF_LIST)
+
+lib_LTLIBRARIES = \
+ libgdm.la \
+ $(END_OF_LIST)
+
+libgdmdir = $(includedir)/gdm
+libgdm_HEADERS = \
+ gdm-client-glue.h \
+ gdm-client.h \
+ gdm-sessions.h \
+ gdm-user-switching.h \
+ $(END_OF_LIST)
+
+libgdm_la_CFLAGS = \
+ $(LIBGDM_CFLAGS) \
+ $(SYSTEMD_CFLAGS) \
+ $(END_OF_LIST)
+libgdm_la_LDFLAGS = \
+ -export-symbols-regex '^[^_].*' \
+ -version-info $(LT_CURRENT):$(LT_REVISION):$(LT_AGE) \
+ -no-undefined \
+ $(END_OF_LIST)
+
+libgdm_la_LIBADD = \
+ $(LIBGDM_LIBS) \
+ $(SYSTEMD_LIBS) \
+ $(END_OF_LIST)
+
+libgdm_la_SOURCES = \
+ $(libgdm_HEADERS) \
+ gdm-client.c \
+ gdm-sessions.c \
+ gdm-user-switching.c \
+ $(END_OF_LIST)
+
+nodist_libgdm_la_SOURCES = \
+ gdm-client-glue.c \
+ gdm-client-glue.h \
+ gdm-manager-glue.c \
+ gdm-manager-glue.h \
+ $(END_OF_LIST)
+
+pkgconfigdir = $(libdir)/pkgconfig
+dist_pkgconfig_DATA = gdm.pc
+
+-include $(INTROSPECTION_MAKEFILE)
+
+if HAVE_INTROSPECTION
+girdir = $(datadir)/gir-1.0
+gir_DATA = Gdm-1.0.gir
+typelibsdir = $(libdir)/girepository-1.0
+typelibs_DATA = $(gir_DATA:.gir=.typelib)
+INTROSPECTION_GIRS = $(gir_DATA)
+
+Gdm-1.0.gir: \
+ $(INTROSPECTION_SCANNER) \
+ libgdm.la \
+ Makefile \
+ $(END_OF_LIST)
+
+Gdm_1_0_gir_SCANNERFLAGS = \
+ --warn-all \
+ --namespace=Gdm \
+ --identifier-prefix Gdm \
+ $(AM_CPPFLAGS) \
+ $(libgdm_la_CFLAGS) \
+ $(END_OF_LIST)
+
+Gdm_1_0_gir_INCLUDES = $(LIBGDM_GIR_INCLUDES)
+Gdm_1_0_gir_LIBS = libgdm.la
+Gdm_1_0_gir_FILES = \
+ $(filter-out %-private.h, $(libgdm_la_SOURCES)) \
+ $(filter-out %-private.h, $(nodist_libgdm_la_SOURCES)) \
+ $(END_OF_LIST)
+
+CLEANFILES += $(gir_DATA) $(typelibs_DATA)
+endif
+
+MAINTAINERCLEANFILES = Makefile.in
diff --git a/libgdm/gdm-client.c b/libgdm/gdm-client.c
new file mode 100644
index 00000000..4542c3ed
--- /dev/null
+++ b/libgdm/gdm-client.c
@@ -0,0 +1,1445 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ * Copyright (C) 2012 Giovanni Campagna <scampa.giovanni@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <glib-object.h>
+
+#include "gdm-client.h"
+#include "gdm-client-glue.h"
+#include "gdm-manager-glue.h"
+
+#define GDM_CLIENT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GDM_TYPE_CLIENT, GdmClientPrivate))
+
+#define SESSION_DBUS_PATH "/org/gnome/DisplayManager/Session"
+
+struct GdmClientPrivate
+{
+ GdmManager *manager;
+ GdmUserVerifier *user_verifier;
+ GdmGreeter *greeter;
+ GdmRemoteGreeter *remote_greeter;
+ GdmChooser *chooser;
+ GDBusConnection *connection;
+ char *address;
+
+ GList *pending_opens;
+};
+
+static void gdm_client_class_init (GdmClientClass *klass);
+static void gdm_client_init (GdmClient *client);
+static void gdm_client_finalize (GObject *object);
+
+G_DEFINE_TYPE (GdmClient, gdm_client, G_TYPE_OBJECT);
+
+static gpointer client_object = NULL;
+
+GQuark
+gdm_client_error_quark (void)
+{
+ static GQuark error_quark = 0;
+
+ if (error_quark == 0)
+ error_quark = g_quark_from_static_string ("gdm-client");
+
+ return error_quark;
+}
+
+static void
+on_got_manager (GdmManager *manager,
+ GAsyncResult *result,
+ GSimpleAsyncResult *operation_result)
+{
+ GdmClient *client;
+ GdmManager *new_manager;
+ GError *error;
+
+ client = GDM_CLIENT (g_async_result_get_source_object (G_ASYNC_RESULT (operation_result)));
+
+ error = NULL;
+ new_manager = gdm_manager_proxy_new_finish (result, &error);
+
+ if (client->priv->manager == NULL) {
+ client->priv->manager = new_manager;
+
+ } else {
+ g_object_ref (client->priv->manager);
+ g_object_unref (new_manager);
+
+ g_clear_error (&error);
+ }
+
+ if (error != NULL) {
+ g_simple_async_result_take_error (operation_result, error);
+ } else {
+ g_simple_async_result_set_op_res_gpointer (operation_result,
+ g_object_ref (client->priv->manager),
+ (GDestroyNotify)
+ g_object_unref);
+ }
+
+ g_simple_async_result_complete_in_idle (operation_result);
+}
+
+static void
+get_manager (GdmClient *client,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GSimpleAsyncResult *result;
+
+ result = g_simple_async_result_new (G_OBJECT (client),
+ callback,
+ user_data,
+ get_manager);
+ g_simple_async_result_set_check_cancellable (result, cancellable);
+
+ if (client->priv->manager != NULL) {
+ g_simple_async_result_set_op_res_gpointer (result,
+ g_object_ref (client->priv->manager),
+ (GDestroyNotify)
+ g_object_unref);
+ g_simple_async_result_complete_in_idle (result);
+ return;
+ }
+
+ gdm_manager_proxy_new_for_bus (G_BUS_TYPE_SYSTEM,
+ G_DBUS_PROXY_FLAGS_NONE,
+ "org.gnome.DisplayManager",
+ "/org/gnome/DisplayManager/Manager",
+ cancellable,
+ (GAsyncReadyCallback)
+ on_got_manager,
+ result);
+}
+
+static void
+on_user_verifier_proxy_created (GObject *source,
+ GAsyncResult *result,
+ GSimpleAsyncResult *operation_result)
+{
+ GdmUserVerifier *user_verifier;
+ GError *error = NULL;
+
+ user_verifier = gdm_user_verifier_proxy_new_finish (result, &error);
+ if (user_verifier == NULL) {
+ g_simple_async_result_take_error (operation_result, error);
+ g_simple_async_result_complete_in_idle (operation_result);
+ return;
+ }
+
+ g_debug ("UserVerifier %p created", user_verifier);
+
+ g_simple_async_result_set_op_res_gpointer (operation_result,
+ user_verifier,
+ (GDestroyNotify)
+ g_object_unref);
+ g_simple_async_result_complete_in_idle (operation_result);
+}
+
+static void
+on_reauthentication_channel_connected (GDBusConnection *connection,
+ GAsyncResult *result,
+ GSimpleAsyncResult *operation_result)
+{
+ GCancellable *cancellable;
+ GError *error;
+
+ error = NULL;
+ if (!g_dbus_connection_new_for_address_finish (result, &error)) {
+ g_simple_async_result_take_error (operation_result, error);
+ g_simple_async_result_complete_in_idle (operation_result);
+ return;
+ }
+
+ cancellable = g_object_get_data (G_OBJECT (operation_result), "cancellable");
+ gdm_user_verifier_proxy_new (connection,
+ G_DBUS_PROXY_FLAGS_NONE,
+ NULL,
+ SESSION_DBUS_PATH,
+ cancellable,
+ (GAsyncReadyCallback)
+ on_user_verifier_proxy_created,
+ operation_result);
+}
+
+static void
+on_reauthentication_channel_opened (GdmManager *manager,
+ GAsyncResult *result,
+ GSimpleAsyncResult *operation_result)
+{
+ GCancellable *cancellable;
+ char *address;
+ GError *error;
+
+ error = NULL;
+ if (!gdm_manager_call_open_reauthentication_channel_finish (manager,
+ &address,
+ result,
+ &error)) {
+ g_simple_async_result_take_error (operation_result, error);
+ g_simple_async_result_complete_in_idle (operation_result);
+ return;
+ }
+
+ cancellable = g_object_get_data (G_OBJECT (operation_result), "cancellable");
+ g_dbus_connection_new_for_address (address,
+ G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
+ NULL,
+ cancellable,
+ (GAsyncReadyCallback)
+ on_reauthentication_channel_connected,
+ operation_result);
+}
+
+static void
+on_got_manager_for_reauthentication (GdmClient *client,
+ GAsyncResult *result,
+ GSimpleAsyncResult *operation_result)
+{
+ GCancellable *cancellable;
+ char *username;
+ GError *error;
+
+ error = NULL;
+ if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
+ &error)) {
+ g_simple_async_result_take_error (operation_result, error);
+ g_simple_async_result_complete_in_idle (operation_result);
+ return;
+ }
+
+ cancellable = g_object_get_data (G_OBJECT (operation_result), "cancellable");
+ username = g_object_get_data (G_OBJECT (operation_result), "username");
+ gdm_manager_call_open_reauthentication_channel (client->priv->manager,
+ username,
+ cancellable,
+ (GAsyncReadyCallback)
+ on_reauthentication_channel_opened,
+ operation_result);
+
+}
+
+static gboolean
+gdm_client_open_connection_sync (GdmClient *client,
+ GCancellable *cancellable,
+ GError **error)
+{
+ gboolean ret;
+
+ g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);
+
+ if (client->priv->manager == NULL) {
+ client->priv->manager = gdm_manager_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
+ G_DBUS_PROXY_FLAGS_NONE,
+ "org.gnome.DisplayManager",
+ "/org/gnome/DisplayManager/Manager",
+ cancellable,
+ error);
+
+ if (client->priv->manager == NULL) {
+ goto out;
+ }
+ } else {
+ client->priv->manager = g_object_ref (client->priv->manager);
+ }
+
+ if (client->priv->connection == NULL) {
+ ret = gdm_manager_call_open_session_sync (client->priv->manager,
+ &client->priv->address,
+ cancellable,
+ error);
+
+ if (!ret) {
+ g_clear_object (&client->priv->manager);
+ goto out;
+ }
+
+ g_debug ("GdmClient: connecting to address: %s", client->priv->address);
+
+ client->priv->connection = g_dbus_connection_new_for_address_sync (client->priv->address,
+ G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
+ NULL,
+ cancellable,
+ error);
+
+ if (client->priv->connection == NULL) {
+ g_clear_object (&client->priv->manager);
+ g_clear_pointer (&client->priv->address, g_free);
+ goto out;
+ }
+ } else {
+ client->priv->connection = g_object_ref (client->priv->connection);
+ }
+
+ out:
+ return client->priv->connection != NULL;
+}
+
+static void
+on_connected (GDBusConnection *connection,
+ GAsyncResult *result,
+ GSimpleAsyncResult *operation_result)
+{
+ GError *error;
+
+ error = NULL;
+ if (!g_dbus_connection_new_for_address_finish (result,
+ &error)) {
+ g_simple_async_result_take_error (operation_result, error);
+ g_simple_async_result_complete_in_idle (operation_result);
+ return;
+ }
+
+ g_simple_async_result_set_op_res_gpointer (operation_result,
+ g_object_ref (connection),
+ (GDestroyNotify)
+ g_object_unref);
+ g_simple_async_result_complete_in_idle (operation_result);
+}
+
+static void
+on_session_opened (GdmManager *manager,
+ GAsyncResult *result,
+ GSimpleAsyncResult *operation_result)
+{
+ GdmClient *client;
+ GCancellable *cancellable;
+ GError *error;
+
+ client = GDM_CLIENT (g_async_result_get_source_object (G_ASYNC_RESULT (operation_result)));
+
+ error = NULL;
+ if (!gdm_manager_call_open_session_finish (manager,
+ &client->priv->address,
+ result,
+ &error)) {
+ g_simple_async_result_take_error (operation_result, error);
+ g_simple_async_result_complete_in_idle (operation_result);
+ return;
+ }
+
+ cancellable = g_object_get_data (G_OBJECT (operation_result), "cancellable");
+ g_dbus_connection_new_for_address (client->priv->address,
+ G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
+ NULL,
+ cancellable,
+ (GAsyncReadyCallback)
+ on_connected,
+ operation_result);
+}
+
+static void
+on_got_manager_for_opening_connection (GdmClient *client,
+ GAsyncResult *result,
+ GSimpleAsyncResult *operation_result)
+{
+ GCancellable *cancellable;
+ GError *error;
+
+ error = NULL;
+ if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
+ &error)) {
+ g_simple_async_result_take_error (operation_result, error);
+ g_simple_async_result_complete_in_idle (operation_result);
+ return;
+ }
+
+ cancellable = g_object_get_data (G_OBJECT (operation_result), "cancellable");
+ gdm_manager_call_open_session (client->priv->manager,
+ cancellable,
+ (GAsyncReadyCallback)
+ on_session_opened,
+ operation_result);
+}
+
+static void
+finish_pending_opens (GdmClient *client,
+ GError *error)
+{
+ GList *node;
+
+ for (node = client->priv->pending_opens;
+ node != NULL;
+ node = node->next) {
+
+ GSimpleAsyncResult *pending_result = node->data;
+
+ g_simple_async_result_set_from_error (pending_result, error);
+ g_simple_async_result_complete_in_idle (pending_result);
+ g_object_unref (pending_result);
+ }
+ g_clear_pointer (&client->priv->pending_opens,
+ (GDestroyNotify) g_list_free);
+}
+
+static gboolean
+gdm_client_open_connection_finish (GdmClient *client,
+ GAsyncResult *result,
+ GError **error)
+{
+ g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);
+
+ if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
+ error)) {
+ finish_pending_opens (client, *error);
+ return FALSE;
+ }
+
+ if (client->priv->connection == NULL) {
+ client->priv->connection = g_object_ref (g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result)));
+ }
+
+ finish_pending_opens (client, NULL);
+ return TRUE;
+}
+
+static void
+gdm_client_open_connection (GdmClient *client,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GSimpleAsyncResult *operation_result;
+
+ g_return_if_fail (GDM_IS_CLIENT (client));
+
+ operation_result = g_simple_async_result_new (G_OBJECT (client),
+ callback,
+ user_data,
+ gdm_client_open_connection);
+ g_simple_async_result_set_check_cancellable (operation_result, cancellable);
+
+ g_object_set_data (G_OBJECT (operation_result),
+ "cancellable",
+ cancellable);
+
+ if (client->priv->connection != NULL) {
+ g_simple_async_result_set_op_res_gpointer (operation_result,
+ g_object_ref (client->priv->connection),
+ (GDestroyNotify)
+ g_object_unref);
+ g_simple_async_result_complete_in_idle (operation_result);
+ return;
+ }
+
+ if (client->priv->pending_opens == NULL) {
+ get_manager (client,
+ cancellable,
+ (GAsyncReadyCallback)
+ on_got_manager_for_opening_connection,
+ operation_result);
+ } else {
+ client->priv->pending_opens = g_list_prepend (client->priv->pending_opens,
+ operation_result);
+ }
+
+}
+
+/**
+ * gdm_client_open_reauthentication_channel_sync:
+ * @client: a #GdmClient
+ * @username: user to reauthenticate
+ * @cancellable: a #GCancellable
+ * @error: a #GError
+ *
+ * Gets a #GdmUserVerifier object that can be used to
+ * reauthenticate an already logged in user. Free with
+ * g_object_unref to close reauthentication channel.
+ *
+ * Returns: (transfer full): #GdmUserVerifier or %NULL if @username is not
+ * already logged in.
+ */
+GdmUserVerifier *
+gdm_client_open_reauthentication_channel_sync (GdmClient *client,
+ const char *username,
+ GCancellable *cancellable,
+ GError **error)
+{
+ GDBusConnection *connection;
+ GdmUserVerifier *user_verifier = NULL;
+ gboolean ret;
+ char *address;
+
+ g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);
+
+ if (client->priv->manager == NULL) {
+ client->priv->manager = gdm_manager_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
+ G_DBUS_PROXY_FLAGS_NONE,
+ "org.gnome.DisplayManager",
+ "/org/gnome/DisplayManager/Manager",
+ cancellable,
+ error);
+
+ if (client->priv->manager == NULL) {
+ goto out;
+ }
+ } else {
+ client->priv->manager = g_object_ref (client->priv->manager);
+ }
+
+ ret = gdm_manager_call_open_reauthentication_channel_sync (client->priv->manager,
+ username,
+ &address,
+ cancellable,
+ error);
+
+ if (!ret) {
+ goto out;
+ }
+
+ g_debug ("GdmClient: connecting to address: %s", client->priv->address);
+
+ connection = g_dbus_connection_new_for_address_sync (address,
+ G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
+ NULL,
+ cancellable,
+ error);
+
+ if (connection == NULL) {
+ g_free (address);
+ goto out;
+ }
+ g_free (address);
+
+ user_verifier = gdm_user_verifier_proxy_new_sync (connection,
+ G_DBUS_PROXY_FLAGS_NONE,
+ NULL,
+ SESSION_DBUS_PATH,
+ cancellable,
+ error);
+
+ if (user_verifier != NULL) {
+ g_object_weak_ref (G_OBJECT (user_verifier),
+ (GWeakNotify)
+ g_object_unref,
+ connection);
+
+ g_object_weak_ref (G_OBJECT (user_verifier),
+ (GWeakNotify)
+ g_clear_object,
+ &client->priv->manager);
+ }
+
+ out:
+ return user_verifier;
+}
+
+/**
+ * gdm_client_open_reauthentication_channel:
+ * @client: a #GdmClient
+ * @username: user to reauthenticate
+ * @callback: a #GAsyncReadyCallback to call when the request is satisfied
+ * @user_data: The data to pass to @callback
+ * @cancellable: a #GCancellable
+ *
+ * Gets a #GdmUserVerifier object that can be used to
+ * reauthenticate an already logged in user.
+ */
+void
+gdm_client_open_reauthentication_channel (GdmClient *client,
+ const char *username,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GSimpleAsyncResult *operation_result;
+
+ g_return_if_fail (GDM_IS_CLIENT (client));
+
+ operation_result = g_simple_async_result_new (G_OBJECT (client),
+ callback,
+ user_data,
+ gdm_client_open_reauthentication_channel);
+ g_simple_async_result_set_check_cancellable (operation_result, cancellable);
+ g_object_set_data (G_OBJECT (operation_result),
+ "cancellable",
+ cancellable);
+
+ g_object_set_data_full (G_OBJECT (operation_result),
+ "username",
+ g_strdup (username),
+ (GDestroyNotify)
+ g_free);
+
+ get_manager (client,
+ cancellable,
+ (GAsyncReadyCallback)
+ on_got_manager_for_reauthentication,
+ operation_result);
+}
+
+/**
+ * gdm_client_open_reauthentication_channel_finish:
+ * @client: a #GdmClient
+ * @result: The #GAsyncResult from the callback
+ * @error: a #GError
+ *
+ * Finishes an operation started with
+ * gdm_client_open_reauthentication_channel().
+ *
+ * Returns: (transfer full): a #GdmUserVerifier
+ */
+GdmUserVerifier *
+gdm_client_open_reauthentication_channel_finish (GdmClient *client,
+ GAsyncResult *result,
+ GError **error)
+{
+ GdmUserVerifier *user_verifier;
+
+ g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);
+
+ if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
+ error)) {
+ return NULL;
+ }
+
+ user_verifier = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
+
+ return g_object_ref (user_verifier);
+}
+
+/**
+ * gdm_client_get_user_verifier_sync:
+ * @client: a #GdmClient
+ * @cancellable: a #GCancellable
+ * @error: a #GError
+ *
+ * Gets a #GdmUserVerifier object that can be used to
+ * verify a user's local account.
+ *
+ * Returns: (transfer full): #GdmUserVerifier or %NULL if not connected
+ */
+GdmUserVerifier *
+gdm_client_get_user_verifier_sync (GdmClient *client,
+ GCancellable *cancellable,
+ GError **error)
+{
+ if (client->priv->user_verifier != NULL) {
+ return g_object_ref (client->priv->user_verifier);
+ }
+
+ if (!gdm_client_open_connection_sync (client, cancellable, error)) {
+ return NULL;
+ }
+
+ client->priv->user_verifier = gdm_user_verifier_proxy_new_sync (client->priv->connection,
+ G_DBUS_PROXY_FLAGS_NONE,
+ NULL,
+ SESSION_DBUS_PATH,
+ cancellable,
+ error);
+
+ if (client->priv->user_verifier != NULL) {
+ g_object_add_weak_pointer (G_OBJECT (client->priv->user_verifier),
+ (gpointer *)
+ &client->priv->user_verifier);
+ g_object_weak_ref (G_OBJECT (client->priv->user_verifier),
+ (GWeakNotify)
+ g_clear_object,
+ &client->priv->manager);
+ g_object_weak_ref (G_OBJECT (client->priv->user_verifier),
+ (GWeakNotify)
+ g_clear_object,
+ &client->priv->connection);
+ }
+
+ return client->priv->user_verifier;
+}
+
+static void
+on_connection_opened_for_user_verifier (GdmClient *client,
+ GAsyncResult *result,
+ GSimpleAsyncResult *operation_result)
+{
+ GCancellable *cancellable;
+ GError *error;
+
+ error = NULL;
+ if (!gdm_client_open_connection_finish (client, result, &error)) {
+ g_simple_async_result_take_error (operation_result, error);
+ g_simple_async_result_complete_in_idle (operation_result);
+ return;
+ }
+
+ cancellable = g_object_get_data (G_OBJECT (operation_result), "cancellable");
+ gdm_user_verifier_proxy_new (client->priv->connection,
+ G_DBUS_PROXY_FLAGS_NONE,
+ NULL,
+ SESSION_DBUS_PATH,
+ cancellable,
+ (GAsyncReadyCallback)
+ on_user_verifier_proxy_created,
+ operation_result);
+}
+
+/**
+ * gdm_client_get_user_verifier:
+ * @client: a #GdmClient
+ * @callback: a #GAsyncReadyCallback to call when the request is satisfied
+ * @user_data: The data to pass to @callback
+ * @cancellable: a #GCancellable
+ *
+ * Gets a #GdmUserVerifier object that can be used to
+ * verify a user's local account.
+ */
+void
+gdm_client_get_user_verifier (GdmClient *client,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GSimpleAsyncResult *operation_result;
+
+ g_return_if_fail (GDM_IS_CLIENT (client));
+
+ operation_result = g_simple_async_result_new (G_OBJECT (client),
+ callback,
+ user_data,
+ gdm_client_get_user_verifier);
+ g_simple_async_result_set_check_cancellable (operation_result, cancellable);
+
+ g_object_set_data (G_OBJECT (operation_result),
+ "cancellable",
+ cancellable);
+
+ if (client->priv->user_verifier != NULL) {
+ g_simple_async_result_set_op_res_gpointer (operation_result,
+ g_object_ref (client->priv->user_verifier),
+ (GDestroyNotify)
+ g_object_unref);
+ g_simple_async_result_complete_in_idle (operation_result);
+ return;
+ }
+
+ gdm_client_open_connection (client,
+ cancellable,
+ (GAsyncReadyCallback)
+ on_connection_opened_for_user_verifier,
+ operation_result);
+}
+
+/**
+ * gdm_client_get_user_verifier_finish:
+ * @client: a #GdmClient
+ * @result: The #GAsyncResult from the callback
+ * @error: a #GError
+ *
+ * Finishes an operation started with
+ * gdm_client_get_user_verifier().
+ *
+ * Returns: (transfer full): a #GdmUserVerifier
+ */
+GdmUserVerifier *
+gdm_client_get_user_verifier_finish (GdmClient *client,
+ GAsyncResult *result,
+ GError **error)
+{
+ GdmUserVerifier *user_verifier;
+
+ g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);
+
+ if (client->priv->user_verifier != NULL) {
+ return g_object_ref (client->priv->user_verifier);
+ } else if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
+ error)) {
+ return NULL;
+ }
+
+ user_verifier = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
+
+ client->priv->user_verifier = user_verifier;
+
+ g_object_add_weak_pointer (G_OBJECT (client->priv->user_verifier),
+ (gpointer *)
+ &client->priv->user_verifier);
+
+ g_object_weak_ref (G_OBJECT (client->priv->user_verifier),
+ (GWeakNotify)
+ g_object_unref,
+ client->priv->connection);
+
+ g_object_weak_ref (G_OBJECT (client->priv->user_verifier),
+ (GWeakNotify)
+ g_clear_object,
+ &client->priv->manager);
+
+ return g_object_ref (user_verifier);
+}
+
+static void
+on_greeter_proxy_created (GObject *source,
+ GAsyncResult *result,
+ GSimpleAsyncResult *operation_result)
+{
+ GdmGreeter *greeter;
+ GError *error = NULL;
+
+ greeter = gdm_greeter_proxy_new_finish (result, &error);
+ if (greeter == NULL) {
+ g_simple_async_result_take_error (operation_result, error);
+ g_simple_async_result_complete_in_idle (operation_result);
+ return;
+ }
+
+ g_simple_async_result_set_op_res_gpointer (operation_result,
+ greeter,
+ (GDestroyNotify)
+ g_object_unref);
+ g_simple_async_result_complete_in_idle (operation_result);
+}
+
+static void
+on_connection_opened_for_greeter (GdmClient *client,
+ GAsyncResult *result,
+ GSimpleAsyncResult *operation_result)
+{
+ GCancellable *cancellable;
+ GError *error;
+
+ error = NULL;
+ if (!gdm_client_open_connection_finish (client, result, &error)) {
+ g_simple_async_result_take_error (operation_result, error);
+ g_simple_async_result_complete_in_idle (operation_result);
+ return;
+ }
+
+ cancellable = g_object_get_data (G_OBJECT (operation_result), "cancellable");
+ gdm_greeter_proxy_new (client->priv->connection,
+ G_DBUS_PROXY_FLAGS_NONE,
+ NULL,
+ SESSION_DBUS_PATH,
+ cancellable,
+ (GAsyncReadyCallback)
+ on_greeter_proxy_created,
+ operation_result);
+}
+
+/**
+ * gdm_client_get_greeter:
+ * @client: a #GdmClient
+ * @callback: a #GAsyncReadyCallback to call when the request is satisfied
+ * @user_data: The data to pass to @callback
+ * @cancellable: a #GCancellable
+ *
+ * Gets a #GdmGreeter object that can be used to
+ * verify a user's local account.
+ */
+void
+gdm_client_get_greeter (GdmClient *client,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GSimpleAsyncResult *operation_result;
+
+ g_return_if_fail (GDM_IS_CLIENT (client));
+
+ operation_result = g_simple_async_result_new (G_OBJECT (client),
+ callback,
+ user_data,
+ gdm_client_get_greeter);
+ g_simple_async_result_set_check_cancellable (operation_result, cancellable);
+
+ g_object_set_data (G_OBJECT (operation_result),
+ "cancellable",
+ cancellable);
+
+ if (client->priv->greeter != NULL) {
+ g_simple_async_result_set_op_res_gpointer (operation_result,
+ g_object_ref (client->priv->greeter),
+ (GDestroyNotify)
+ g_object_unref);
+ g_simple_async_result_complete_in_idle (operation_result);
+ return;
+ }
+
+ gdm_client_open_connection (client,
+ cancellable,
+ (GAsyncReadyCallback)
+ on_connection_opened_for_greeter,
+ operation_result);
+}
+
+/**
+ * gdm_client_get_greeter_finish:
+ * @client: a #GdmClient
+ * @result: The #GAsyncResult from the callback
+ * @error: a #GError
+ *
+ * Finishes an operation started with
+ * gdm_client_get_greeter().
+ *
+ * Returns: (transfer full): a #GdmGreeter
+ */
+GdmGreeter *
+gdm_client_get_greeter_finish (GdmClient *client,
+ GAsyncResult *result,
+ GError **error)
+{
+ GdmGreeter *greeter;
+
+ g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);
+
+ if (client->priv->greeter != NULL) {
+ return g_object_ref (client->priv->greeter);
+ } else if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
+ error)) {
+ return NULL;
+ }
+
+ greeter = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
+
+ client->priv->greeter = greeter;
+
+ g_object_add_weak_pointer (G_OBJECT (client->priv->greeter),
+ (gpointer *)
+ &client->priv->greeter);
+
+ g_object_weak_ref (G_OBJECT (client->priv->greeter),
+ (GWeakNotify)
+ g_object_unref,
+ client->priv->connection);
+
+ g_object_weak_ref (G_OBJECT (client->priv->greeter),
+ (GWeakNotify)
+ g_clear_object,
+ &client->priv->manager);
+
+ return g_object_ref (greeter);
+}
+
+/**
+ * gdm_client_get_greeter_sync:
+ * @client: a #GdmClient
+ * @cancellable: a #GCancellable
+ * @error: a #GError
+ *
+ * Gets a #GdmGreeter object that can be used
+ * to do do various login screen related tasks, such
+ * as selecting a users session, and starting that
+ * session.
+ *
+ * Returns: (transfer full): #GdmGreeter or %NULL if caller is not a greeter
+ */
+GdmGreeter *
+gdm_client_get_greeter_sync (GdmClient *client,
+ GCancellable *cancellable,
+ GError **error)
+{
+ if (client->priv->greeter != NULL) {
+ return g_object_ref (client->priv->greeter);
+ }
+
+ if (!gdm_client_open_connection_sync (client, cancellable, error)) {
+ return NULL;
+ }
+
+ client->priv->greeter = gdm_greeter_proxy_new_sync (client->priv->connection,
+ G_DBUS_PROXY_FLAGS_NONE,
+ NULL,
+ SESSION_DBUS_PATH,
+ cancellable,
+ error);
+
+ if (client->priv->greeter != NULL) {
+ g_object_add_weak_pointer (G_OBJECT (client->priv->greeter),
+ (gpointer *)
+ &client->priv->greeter);
+ g_object_weak_ref (G_OBJECT (client->priv->greeter),
+ (GWeakNotify)
+ g_clear_object,
+ &client->priv->manager);
+ g_object_weak_ref (G_OBJECT (client->priv->greeter),
+ (GWeakNotify)
+ g_clear_object,
+ &client->priv->connection);
+ }
+
+ return client->priv->greeter;
+}
+
+static void
+on_remote_greeter_proxy_created (GObject *object,
+ GAsyncResult *result,
+ GSimpleAsyncResult *operation_result)
+{
+ GdmRemoteGreeter *remote_greeter;
+ GError *error = NULL;
+
+ remote_greeter = gdm_remote_greeter_proxy_new_finish (result, &error);
+ if (remote_greeter == NULL) {
+ g_simple_async_result_take_error (operation_result, error);
+ g_simple_async_result_complete_in_idle (operation_result);
+ return;
+ }
+
+ g_simple_async_result_set_op_res_gpointer (operation_result,
+ remote_greeter,
+ (GDestroyNotify)
+ g_object_unref);
+ g_simple_async_result_complete_in_idle (operation_result);
+}
+
+static void
+on_connection_opened_for_remote_greeter (GdmClient *client,
+ GAsyncResult *result,
+ GSimpleAsyncResult *operation_result)
+{
+ GCancellable *cancellable;
+ GError *error;
+
+ error = NULL;
+ if (!gdm_client_open_connection_finish (client, result, &error)) {
+ g_simple_async_result_take_error (operation_result, error);
+ g_simple_async_result_complete_in_idle (operation_result);
+ return;
+ }
+
+ cancellable = g_object_get_data (G_OBJECT (operation_result), "cancellable");
+ gdm_remote_greeter_proxy_new (client->priv->connection,
+ G_DBUS_PROXY_FLAGS_NONE,
+ NULL,
+ SESSION_DBUS_PATH,
+ cancellable,
+ (GAsyncReadyCallback)
+ on_remote_greeter_proxy_created,
+ operation_result);
+}
+
+/**
+ * gdm_client_get_remote_greeter:
+ * @client: a #GdmClient
+ * @callback: a #GAsyncReadyCallback to call when the request is satisfied
+ * @user_data: The data to pass to @callback
+ * @cancellable: a #GCancellable
+ *
+ * Gets a #GdmRemoteGreeter object that can be used to
+ * verify a user's local account.
+ */
+void
+gdm_client_get_remote_greeter (GdmClient *client,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GSimpleAsyncResult *operation_result;
+
+ g_return_if_fail (GDM_IS_CLIENT (client));
+
+ operation_result = g_simple_async_result_new (G_OBJECT (client),
+ callback,
+ user_data,
+ gdm_client_get_remote_greeter);
+ g_simple_async_result_set_check_cancellable (operation_result, cancellable);
+
+ g_object_set_data (G_OBJECT (operation_result),
+ "cancellable",
+ cancellable);
+
+ if (client->priv->remote_greeter != NULL) {
+ g_simple_async_result_set_op_res_gpointer (operation_result,
+ g_object_ref (client->priv->remote_greeter),
+ (GDestroyNotify)
+ g_object_unref);
+ g_simple_async_result_complete_in_idle (operation_result);
+ return;
+ }
+
+ gdm_client_open_connection (client,
+ cancellable,
+ (GAsyncReadyCallback)
+ on_connection_opened_for_remote_greeter,
+ operation_result);
+}
+
+/**
+ * gdm_client_get_remote_greeter_finish:
+ * @client: a #GdmClient
+ * @result: The #GAsyncResult from the callback
+ * @error: a #GError
+ *
+ * Finishes an operation started with
+ * gdm_client_get_remote_greeter().
+ *
+ * Returns: (transfer full): a #GdmRemoteGreeter
+ */
+GdmRemoteGreeter *
+gdm_client_get_remote_greeter_finish (GdmClient *client,
+ GAsyncResult *result,
+ GError **error)
+{
+ GdmRemoteGreeter *remote_greeter;
+
+ g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);
+
+ if (client->priv->remote_greeter != NULL) {
+ return g_object_ref (client->priv->remote_greeter);
+ } else if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
+ error)) {
+ return NULL;
+ }
+
+ remote_greeter = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
+
+ client->priv->remote_greeter = remote_greeter;
+
+ g_object_add_weak_pointer (G_OBJECT (client->priv->remote_greeter),
+ (gpointer *)
+ &client->priv->remote_greeter);
+
+ g_object_weak_ref (G_OBJECT (client->priv->remote_greeter),
+ (GWeakNotify)
+ g_object_unref,
+ client->priv->connection);
+
+ g_object_weak_ref (G_OBJECT (client->priv->remote_greeter),
+ (GWeakNotify)
+ g_clear_object,
+ &client->priv->manager);
+
+ return g_object_ref (remote_greeter);
+}
+
+/**
+ * gdm_client_get_remote_greeter_sync:
+ * @client: a #GdmClient
+ * @cancellable: a #GCancellable
+ * @error: a #GError
+ *
+ * Gets a #GdmRemoteGreeter object that can be used
+ * to do do various remote login screen related tasks,
+ * such as disconnecting.
+ *
+ * Returns: (transfer full): #GdmRemoteGreeter or %NULL if caller is not remote
+ */
+GdmRemoteGreeter *
+gdm_client_get_remote_greeter_sync (GdmClient *client,
+ GCancellable *cancellable,
+ GError **error)
+{
+ if (client->priv->remote_greeter != NULL) {
+ return g_object_ref (client->priv->remote_greeter);
+ }
+
+ if (!gdm_client_open_connection_sync (client, cancellable, error)) {
+ return NULL;
+ }
+
+ client->priv->remote_greeter = gdm_remote_greeter_proxy_new_sync (client->priv->connection,
+ G_DBUS_PROXY_FLAGS_NONE,
+ NULL,
+ SESSION_DBUS_PATH,
+ cancellable,
+ error);
+
+ if (client->priv->remote_greeter != NULL) {
+ g_object_add_weak_pointer (G_OBJECT (client->priv->remote_greeter),
+ (gpointer *)
+ &client->priv->remote_greeter);
+ g_object_weak_ref (G_OBJECT (client->priv->remote_greeter),
+ (GWeakNotify)
+ g_clear_object,
+ &client->priv->manager);
+ g_object_weak_ref (G_OBJECT (client->priv->remote_greeter),
+ (GWeakNotify)
+ g_clear_object,
+ &client->priv->connection);
+ }
+
+ return client->priv->remote_greeter;
+}
+
+static void
+on_chooser_proxy_created (GObject *source,
+ GAsyncResult *result,
+ GSimpleAsyncResult *operation_result)
+{
+ GdmChooser *chooser;
+ GError *error = NULL;
+
+ chooser = gdm_chooser_proxy_new_finish (result, &error);
+ if (chooser == NULL) {
+ g_simple_async_result_take_error (operation_result, error);
+ g_simple_async_result_complete_in_idle (operation_result);
+ return;
+ }
+
+ g_simple_async_result_set_op_res_gpointer (operation_result,
+ chooser,
+ (GDestroyNotify)
+ g_object_unref);
+ g_simple_async_result_complete_in_idle (operation_result);
+}
+
+static void
+on_connection_opened_for_chooser (GdmClient *client,
+ GAsyncResult *result,
+ GSimpleAsyncResult *operation_result)
+{
+ GCancellable *cancellable;
+ GError *error;
+
+ error = NULL;
+ if (!gdm_client_open_connection_finish (client, result, &error)) {
+ g_simple_async_result_take_error (operation_result, error);
+ g_simple_async_result_complete_in_idle (operation_result);
+ return;
+ }
+
+ cancellable = g_object_get_data (G_OBJECT (operation_result), "cancellable");
+ gdm_chooser_proxy_new (client->priv->connection,
+ G_DBUS_PROXY_FLAGS_NONE,
+ NULL,
+ SESSION_DBUS_PATH,
+ cancellable,
+ (GAsyncReadyCallback)
+ on_chooser_proxy_created,
+ operation_result);
+}
+
+/**
+ * gdm_client_get_chooser:
+ * @client: a #GdmClient
+ * @callback: a #GAsyncReadyCallback to call when the request is satisfied
+ * @user_data: The data to pass to @callback
+ * @cancellable: a #GCancellable
+ *
+ * Gets a #GdmChooser object that can be used to
+ * verify a user's local account.
+ */
+void
+gdm_client_get_chooser (GdmClient *client,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GSimpleAsyncResult *operation_result;
+
+ g_return_if_fail (GDM_IS_CLIENT (client));
+
+ operation_result = g_simple_async_result_new (G_OBJECT (client),
+ callback,
+ user_data,
+ gdm_client_get_chooser);
+ g_simple_async_result_set_check_cancellable (operation_result, cancellable);
+
+ g_object_set_data (G_OBJECT (operation_result),
+ "cancellable",
+ cancellable);
+
+ if (client->priv->chooser != NULL) {
+ g_simple_async_result_set_op_res_gpointer (operation_result,
+ g_object_ref (client->priv->chooser),
+ (GDestroyNotify)
+ g_object_unref);
+ g_simple_async_result_complete_in_idle (operation_result);
+ return;
+ }
+
+ gdm_client_open_connection (client,
+ cancellable,
+ (GAsyncReadyCallback)
+ on_connection_opened_for_chooser,
+ operation_result);
+}
+
+/**
+ * gdm_client_get_chooser_finish:
+ * @client: a #GdmClient
+ * @result: The #GAsyncResult from the callback
+ * @error: a #GError
+ *
+ * Finishes an operation started with
+ * gdm_client_get_chooser().
+ *
+ * Returns: (transfer full): a #GdmChooser
+ */
+GdmChooser *
+gdm_client_get_chooser_finish (GdmClient *client,
+ GAsyncResult *result,
+ GError **error)
+{
+ GdmChooser *chooser;
+
+ g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);
+
+ if (client->priv->chooser != NULL) {
+ return g_object_ref (client->priv->chooser);
+ } else if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
+ error)) {
+ return NULL;
+ }
+
+ chooser = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
+
+ client->priv->chooser = chooser;
+
+ g_object_add_weak_pointer (G_OBJECT (client->priv->chooser),
+ (gpointer *)
+ &client->priv->chooser);
+
+ g_object_weak_ref (G_OBJECT (client->priv->chooser),
+ (GWeakNotify)
+ g_object_unref,
+ client->priv->connection);
+
+ g_object_weak_ref (G_OBJECT (client->priv->chooser),
+ (GWeakNotify)
+ g_clear_object,
+ &client->priv->manager);
+
+ return g_object_ref (chooser);
+}
+
+/**
+ * gdm_client_get_chooser_sync:
+ * @client: a #GdmClient
+ * @cancellable: a #GCancellable
+ * @error: a #GError
+ *
+ * Gets a #GdmChooser object that can be used
+ * to do do various XDMCP chooser related tasks, such
+ * as selecting a host or disconnecting.
+ *
+ * Returns: (transfer full): #GdmChooser or %NULL if caller is not a chooser
+ */
+GdmChooser *
+gdm_client_get_chooser_sync (GdmClient *client,
+ GCancellable *cancellable,
+ GError **error)
+{
+
+ if (client->priv->chooser != NULL) {
+ return g_object_ref (client->priv->chooser);
+ }
+
+ if (!gdm_client_open_connection_sync (client, cancellable, error)) {
+ return NULL;
+ }
+
+ client->priv->chooser = gdm_chooser_proxy_new_sync (client->priv->connection,
+ G_DBUS_PROXY_FLAGS_NONE,
+ NULL,
+ SESSION_DBUS_PATH,
+ cancellable,
+ error);
+
+ if (client->priv->chooser != NULL) {
+ g_object_add_weak_pointer (G_OBJECT (client->priv->chooser),
+ (gpointer *)
+ &client->priv->chooser);
+ g_object_weak_ref (G_OBJECT (client->priv->chooser),
+ (GWeakNotify)
+ g_clear_object,
+ &client->priv->manager);
+ g_object_weak_ref (G_OBJECT (client->priv->chooser),
+ (GWeakNotify)
+ g_clear_object,
+ &client->priv->connection);
+ }
+
+ return client->priv->chooser;
+}
+
+static void
+gdm_client_class_init (GdmClientClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->finalize = gdm_client_finalize;
+
+ g_type_class_add_private (klass, sizeof (GdmClientPrivate));
+
+}
+
+static void
+gdm_client_init (GdmClient *client)
+{
+
+ client->priv = GDM_CLIENT_GET_PRIVATE (client);
+}
+
+static void
+gdm_client_finalize (GObject *object)
+{
+ GdmClient *client;
+
+ g_return_if_fail (object != NULL);
+ g_return_if_fail (GDM_IS_CLIENT (object));
+
+ client = GDM_CLIENT (object);
+
+ g_return_if_fail (client->priv != NULL);
+
+ if (client->priv->user_verifier != NULL) {
+ g_object_remove_weak_pointer (G_OBJECT (client->priv->user_verifier),
+ (gpointer *)
+ &client->priv->user_verifier);
+ }
+
+ if (client->priv->greeter != NULL) {
+ g_object_remove_weak_pointer (G_OBJECT (client->priv->greeter),
+ (gpointer *)
+ &client->priv->greeter);
+ }
+
+ if (client->priv->remote_greeter != NULL) {
+ g_object_remove_weak_pointer (G_OBJECT (client->priv->remote_greeter),
+ (gpointer *)
+ &client->priv->remote_greeter);
+ }
+
+ if (client->priv->chooser != NULL) {
+ g_object_remove_weak_pointer (G_OBJECT (client->priv->chooser),
+ (gpointer *)
+ &client->priv->chooser);
+ }
+
+ g_clear_object (&client->priv->manager);
+ g_clear_object (&client->priv->connection);
+
+ g_free (client->priv->address);
+
+ G_OBJECT_CLASS (gdm_client_parent_class)->finalize (object);
+}
+
+GdmClient *
+gdm_client_new (void)
+{
+ if (client_object != NULL) {
+ g_object_ref (client_object);
+ } else {
+ client_object = g_object_new (GDM_TYPE_CLIENT, NULL);
+ g_object_add_weak_pointer (client_object,
+ (gpointer *) &client_object);
+ }
+
+ return GDM_CLIENT (client_object);
+}
diff --git a/libgdm/gdm-client.h b/libgdm/gdm-client.h
new file mode 100644
index 00000000..cbe2b389
--- /dev/null
+++ b/libgdm/gdm-client.h
@@ -0,0 +1,123 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ * Copyright (C) 2012 Giovanni Campagna <scampa.giovanni@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef __GDM_CLIENT_H
+#define __GDM_CLIENT_H
+
+#include <glib-object.h>
+#include "gdm-client-glue.h"
+
+G_BEGIN_DECLS
+
+#define GDM_TYPE_CLIENT (gdm_client_get_type ())
+#define GDM_CLIENT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GDM_TYPE_CLIENT, GdmClient))
+#define GDM_CLIENT_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GDM_TYPE_CLIENT, GdmClientClass))
+#define GDM_IS_CLIENT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDM_TYPE_CLIENT))
+#define GDM_IS_CLIENT_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GDM_TYPE_CLIENT))
+#define GDM_CLIENT_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDM_TYPE_CLIENT, GdmClientClass))
+
+typedef struct GdmClientPrivate GdmClientPrivate;
+
+typedef struct
+{
+ GObject parent;
+ GdmClientPrivate *priv;
+} GdmClient;
+
+typedef struct
+{
+ GObjectClass parent_class;
+
+} GdmClientClass;
+
+#define GDM_CLIENT_ERROR (gdm_client_error_quark ())
+
+typedef enum _GdmClientError {
+ GDM_CLIENT_ERROR_GENERIC = 0,
+} GdmClientError;
+
+GType gdm_client_get_type (void);
+GQuark gdm_client_error_quark (void);
+
+GdmClient *gdm_client_new (void);
+
+void gdm_client_open_reauthentication_channel (GdmClient *client,
+ const char *username,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
+
+GdmUserVerifier *gdm_client_open_reauthentication_channel_finish (GdmClient *client,
+ GAsyncResult *result,
+ GError **error);
+
+GdmUserVerifier *gdm_client_open_reauthentication_channel_sync (GdmClient *client,
+ const char *username,
+ GCancellable *cancellable,
+ GError **error);
+
+void gdm_client_get_user_verifier (GdmClient *client,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
+GdmUserVerifier *gdm_client_get_user_verifier_finish (GdmClient *client,
+ GAsyncResult *result,
+ GError **error);
+GdmUserVerifier *gdm_client_get_user_verifier_sync (GdmClient *client,
+ GCancellable *cancellable,
+ GError **error);
+
+void gdm_client_get_greeter (GdmClient *client,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
+GdmGreeter *gdm_client_get_greeter_finish (GdmClient *client,
+ GAsyncResult *result,
+ GError **error);
+GdmGreeter *gdm_client_get_greeter_sync (GdmClient *client,
+ GCancellable *cancellable,
+ GError **error);
+
+void gdm_client_get_remote_greeter (GdmClient *client,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
+GdmRemoteGreeter *gdm_client_get_remote_greeter_finish (GdmClient *client,
+ GAsyncResult *result,
+ GError **error);
+GdmRemoteGreeter *gdm_client_get_remote_greeter_sync (GdmClient *client,
+ GCancellable *cancellable,
+ GError **error);
+
+void gdm_client_get_chooser (GdmClient *client,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
+GdmChooser *gdm_client_get_chooser_finish (GdmClient *client,
+ GAsyncResult *result,
+ GError **error);
+GdmChooser *gdm_client_get_chooser_sync (GdmClient *client,
+ GCancellable *cancellable,
+ GError **error);
+
+G_END_DECLS
+
+#endif /* __GDM_CLIENT_H */
diff --git a/libgdm/gdm-sessions.c b/libgdm/gdm-sessions.c
new file mode 100644
index 00000000..0c51c023
--- /dev/null
+++ b/libgdm/gdm-sessions.c
@@ -0,0 +1,280 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright 2008 Red Hat, Inc,
+ * 2007 William Jon McCann <mccann@jhu.edu>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Written by : William Jon McCann <mccann@jhu.edu>
+ * Ray Strode <rstrode@redhat.com>
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <dirent.h>
+#include <sys/stat.h>
+
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+
+#include "gdm-sessions.h"
+
+typedef struct _GdmSessionFile {
+ char *id;
+ char *path;
+ char *translated_name;
+ char *translated_comment;
+} GdmSessionFile;
+
+static GHashTable *gdm_available_sessions_map;
+
+static gboolean gdm_sessions_map_is_initialized = FALSE;
+
+/* adapted from gnome-menus desktop-entries.c */
+static gboolean
+key_file_is_relevant (GKeyFile *key_file)
+{
+ GError *error;
+ gboolean no_display;
+ gboolean hidden;
+ gboolean tryexec_failed;
+ char *tryexec;
+
+ error = NULL;
+ no_display = g_key_file_get_boolean (key_file,
+ G_KEY_FILE_DESKTOP_GROUP,
+ "NoDisplay",
+ &error);
+ if (error) {
+ no_display = FALSE;
+ g_error_free (error);
+ }
+
+ error = NULL;
+ hidden = g_key_file_get_boolean (key_file,
+ G_KEY_FILE_DESKTOP_GROUP,
+ "Hidden",
+ &error);
+ if (error) {
+ hidden = FALSE;
+ g_error_free (error);
+ }
+
+ tryexec_failed = FALSE;
+ tryexec = g_key_file_get_string (key_file,
+ G_KEY_FILE_DESKTOP_GROUP,
+ "TryExec",
+ NULL);
+ if (tryexec) {
+ char *path;
+
+ path = g_find_program_in_path (g_strstrip (tryexec));
+
+ tryexec_failed = (path == NULL);
+
+ g_free (path);
+ g_free (tryexec);
+ }
+
+ if (no_display || hidden || tryexec_failed) {
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static void
+load_session_file (const char *id,
+ const char *path)
+{
+ GKeyFile *key_file;
+ GError *error;
+ gboolean res;
+ GdmSessionFile *session;
+
+ key_file = g_key_file_new ();
+
+ error = NULL;
+ res = g_key_file_load_from_file (key_file, path, 0, &error);
+
+ if (!res) {
+ g_debug ("Failed to load \"%s\": %s\n", path, error->message);
+ g_error_free (error);
+ goto out;
+ }
+
+ if (! g_key_file_has_group (key_file, G_KEY_FILE_DESKTOP_GROUP)) {
+ goto out;
+ }
+
+ res = g_key_file_has_key (key_file, G_KEY_FILE_DESKTOP_GROUP, "Name", NULL);
+ if (! res) {
+ g_debug ("\"%s\" contains no \"Name\" key\n", path);
+ goto out;
+ }
+
+ if (!key_file_is_relevant (key_file)) {
+ g_debug ("\"%s\" is hidden or contains non-executable TryExec program\n", path);
+ goto out;
+ }
+
+ session = g_new0 (GdmSessionFile, 1);
+
+ session->id = g_strdup (id);
+ session->path = g_strdup (path);
+
+ session->translated_name = g_key_file_get_locale_string (key_file, G_KEY_FILE_DESKTOP_GROUP, "Name", NULL, NULL);
+ session->translated_comment = g_key_file_get_locale_string (key_file, G_KEY_FILE_DESKTOP_GROUP, "Comment", NULL, NULL);
+
+ g_hash_table_insert (gdm_available_sessions_map,
+ g_strdup (id),
+ session);
+ out:
+ g_key_file_free (key_file);
+}
+
+static void
+collect_sessions_from_directory (const char *dirname)
+{
+ GDir *dir;
+ const char *filename;
+
+ /* FIXME: add file monitor to directory */
+
+ dir = g_dir_open (dirname, 0, NULL);
+ if (dir == NULL) {
+ return;
+ }
+
+ while ((filename = g_dir_read_name (dir))) {
+ char *id;
+ char *full_path;
+
+ if (! g_str_has_suffix (filename, ".desktop")) {
+ continue;
+ }
+ id = g_strndup (filename, strlen (filename) - strlen (".desktop"));
+
+ full_path = g_build_filename (dirname, filename, NULL);
+
+ load_session_file (id, full_path);
+
+ g_free (id);
+ g_free (full_path);
+ }
+
+ g_dir_close (dir);
+}
+
+static void
+collect_sessions (void)
+{
+ int i;
+ const char *search_dirs[] = {
+ "/etc/X11/sessions/",
+ DMCONFDIR "/Sessions/",
+ DATADIR "/gdm/BuiltInSessions/",
+ DATADIR "/xsessions/",
+ NULL
+ };
+
+ if (gdm_available_sessions_map == NULL) {
+ gdm_available_sessions_map = g_hash_table_new_full (g_str_hash, g_str_equal,
+ g_free, g_free);
+ }
+
+ for (i = 0; search_dirs [i] != NULL; i++) {
+ collect_sessions_from_directory (search_dirs [i]);
+ }
+}
+
+/**
+ * gdm_get_session_ids:
+ *
+ * Reads /usr/share/xsessions and other relevant places for possible sessions
+ * to log into and returns the complete list.
+ *
+ * Returns: (transfer full): a %NULL terminated list of session ids
+ */
+char **
+gdm_get_session_ids (void)
+{
+ GHashTableIter iter;
+ gpointer key, value;
+ GPtrArray *array;
+
+ if (!gdm_sessions_map_is_initialized) {
+ collect_sessions ();
+
+ gdm_sessions_map_is_initialized = TRUE;
+ }
+
+ array = g_ptr_array_new ();
+ g_hash_table_iter_init (&iter, gdm_available_sessions_map);
+ while (g_hash_table_iter_next (&iter, &key, &value)) {
+ GdmSessionFile *session;
+
+ session = (GdmSessionFile *) value;
+
+ g_ptr_array_add (array, g_strdup (session->id));
+ }
+ g_ptr_array_add (array, NULL);
+
+ return (char **) g_ptr_array_free (array, FALSE);
+}
+
+/**
+ * gdm_get_session_name_and_description:
+ * @id: an id from gdm_get_session_ids()
+ * @description: (out): optional returned session description
+ *
+ * Takes an xsession id and returns the name and comment about it.
+ *
+ * Returns: The session name if found, or %NULL otherwise
+ */
+char *
+gdm_get_session_name_and_description (const char *id,
+ char **description)
+{
+ GdmSessionFile *session;
+ char *name;
+
+ if (!gdm_sessions_map_is_initialized) {
+ collect_sessions ();
+
+ gdm_sessions_map_is_initialized = TRUE;
+ }
+
+ session = (GdmSessionFile *) g_hash_table_lookup (gdm_available_sessions_map,
+ id);
+
+ if (session == NULL) {
+ return NULL;
+ }
+
+ name = g_strdup (session->translated_name);
+
+ if (description != NULL) {
+ *description = g_strdup (session->translated_comment);
+ }
+
+ return name;
+}
diff --git a/libgdm/gdm-sessions.h b/libgdm/gdm-sessions.h
new file mode 100644
index 00000000..66e99fdd
--- /dev/null
+++ b/libgdm/gdm-sessions.h
@@ -0,0 +1,37 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright 2008 Red Hat, Inc.
+ * Copyright 2007 William Jon McCann <mccann@jhu.edu>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Written by: Ray Strode
+ * William Jon McCann
+ */
+
+#ifndef __GDM_GREETER_SESSIONS_H
+#define __GDM_GREETER_SESSIONS_H
+
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+char ** gdm_get_session_ids (void);
+char * gdm_get_session_name_and_description (const char *id,
+ char **description);
+
+G_END_DECLS
+
+#endif /* __GDM_SESSION_H */
diff --git a/libgdm/gdm-user-switching.c b/libgdm/gdm-user-switching.c
new file mode 100644
index 00000000..ebfef1c3
--- /dev/null
+++ b/libgdm/gdm-user-switching.c
@@ -0,0 +1,597 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ * Copyright (C) 2012 Giovanni Campagna <scampa.giovanni@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <glib-object.h>
+#include <gio/gio.h>
+
+#ifdef WITH_SYSTEMD
+#include <systemd/sd-login.h>
+#endif
+
+#include "common/gdm-common.h"
+#include "gdm-user-switching.h"
+#include "gdm-client.h"
+
+#ifdef WITH_CONSOLE_KIT
+#define CK_NAME "org.freedesktop.ConsoleKit"
+#define CK_PATH "/org/freedesktop/ConsoleKit"
+#define CK_INTERFACE "org.freedesktop.ConsoleKit"
+
+#define CK_MANAGER_PATH "/org/freedesktop/ConsoleKit/Manager"
+#define CK_MANAGER_INTERFACE "org.freedesktop.ConsoleKit.Manager"
+#define CK_SEAT_INTERFACE "org.freedesktop.ConsoleKit.Seat"
+#define CK_SESSION_INTERFACE "org.freedesktop.ConsoleKit.Session"
+#endif
+
+static gboolean
+create_transient_display (GDBusConnection *connection,
+ GCancellable *cancellable,
+ GError **error)
+{
+ GVariant *reply;
+ const char *value;
+
+ reply = g_dbus_connection_call_sync (connection,
+ "org.gnome.DisplayManager",
+ "/org/gnome/DisplayManager/LocalDisplayFactory",
+ "org.gnome.DisplayManager.LocalDisplayFactory",
+ "CreateTransientDisplay",
+ NULL, /* parameters */
+ G_VARIANT_TYPE ("(o)"),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ cancellable, error);
+ if (reply == NULL) {
+ g_prefix_error (error, _("Unable to create transient display: "));
+ return FALSE;
+ }
+
+ g_variant_get (reply, "(&o)", &value);
+ g_debug ("Started %s", value);
+
+ g_variant_unref (reply);
+ return TRUE;
+}
+
+#ifdef WITH_CONSOLE_KIT
+
+static gboolean
+get_current_session_id (GDBusConnection *connection,
+ char **session_id)
+{
+ GError *local_error = NULL;
+ GVariant *reply;
+
+ reply = g_dbus_connection_call_sync (connection,
+ CK_NAME,
+ CK_MANAGER_PATH,
+ CK_MANAGER_INTERFACE,
+ "GetCurrentSession",
+ NULL, /* parameters */
+ G_VARIANT_TYPE ("(o)"),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL, &local_error);
+ if (reply == NULL) {
+ g_warning ("Unable to determine session: %s", local_error->message);
+ g_error_free (local_error);
+ return FALSE;
+ }
+
+ g_variant_get (reply, "(o)", session_id);
+ g_variant_unref (reply);
+
+ return TRUE;
+}
+
+static gboolean
+get_seat_id_for_session (GDBusConnection *connection,
+ const char *session_id,
+ char **seat_id)
+{
+ GError *local_error = NULL;
+ GVariant *reply;
+
+ reply = g_dbus_connection_call_sync (connection,
+ CK_NAME,
+ session_id,
+ CK_SESSION_INTERFACE,
+ "GetSeatId",
+ NULL, /* parameters */
+ G_VARIANT_TYPE ("(o)"),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL, &local_error);
+ if (reply == NULL) {
+ g_warning ("Unable to determine seat: %s", local_error->message);
+ g_error_free (local_error);
+ return FALSE;
+ }
+
+ g_variant_get (reply, "(o)", seat_id);
+ g_variant_unref (reply);
+
+ return TRUE;
+}
+
+static char *
+get_current_seat_id (GDBusConnection *connection)
+{
+ gboolean res;
+ char *session_id;
+ char *seat_id;
+
+ session_id = NULL;
+ seat_id = NULL;
+
+ res = get_current_session_id (connection, &session_id);
+ if (res) {
+ res = get_seat_id_for_session (connection, session_id, &seat_id);
+ }
+ g_free (session_id);
+
+ return seat_id;
+}
+
+static gboolean
+activate_session_id_for_ck (GDBusConnection *connection,
+ GCancellable *cancellable,
+ const char *seat_id,
+ const char *session_id,
+ GError **error)
+{
+ GVariant *reply;
+
+ reply = g_dbus_connection_call_sync (connection,
+ CK_NAME,
+ seat_id,
+ CK_SEAT_INTERFACE,
+ "ActivateSession",
+ g_variant_new ("(o)", session_id),
+ NULL,
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL, error);
+ if (reply == NULL) {
+ g_prefix_error (error, _("Unable to activate session: "));
+ return FALSE;
+ }
+
+ g_variant_unref (reply);
+
+ return TRUE;
+}
+
+static gboolean
+session_is_login_window (GDBusConnection *connection,
+ const char *session_id)
+{
+ GError *local_error = NULL;
+ GVariant *reply;
+ const char *value;
+ gboolean ret;
+
+ reply = g_dbus_connection_call_sync (connection,
+ CK_NAME,
+ session_id,
+ CK_SESSION_INTERFACE,
+ "GetSessionType",
+ NULL,
+ G_VARIANT_TYPE ("(s)"),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL, &local_error);
+ if (reply == NULL) {
+ g_warning ("Unable to determine session type: %s", local_error->message);
+ g_error_free (local_error);
+ return FALSE;
+ }
+
+ g_variant_get (reply, "(&s)", &value);
+
+ if (value == NULL || value[0] == '\0' || strcmp (value, "LoginWindow") != 0) {
+ ret = FALSE;
+ } else {
+ ret = TRUE;
+ }
+
+ g_variant_unref (reply);
+
+ return ret;
+}
+
+static gboolean
+seat_can_activate_sessions (GDBusConnection *connection,
+ const char *seat_id)
+{
+ GError *local_error = NULL;
+ GVariant *reply;
+ gboolean ret;
+
+ reply = g_dbus_connection_call_sync (connection,
+ CK_NAME,
+ seat_id,
+ CK_SEAT_INTERFACE,
+ "CanActivateSessions",
+ NULL,
+ G_VARIANT_TYPE ("(b)"),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL, &local_error);
+ if (reply == NULL) {
+ g_warning ("Unable to determine if can activate sessions: %s", local_error->message);
+ g_error_free (local_error);
+ return FALSE;
+ }
+
+ g_variant_get (reply, "(b)", &ret);
+ g_variant_unref (reply);
+
+ return ret;
+}
+
+static const char **
+seat_get_sessions (GDBusConnection *connection,
+ const char *seat_id)
+{
+ GError *local_error = NULL;
+ GVariant *reply;
+ const char **value;
+
+ reply = g_dbus_connection_call_sync (connection,
+ CK_NAME,
+ seat_id,
+ CK_SEAT_INTERFACE,
+ "GetSessions",
+ NULL,
+ G_VARIANT_TYPE ("(ao)"),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL, &local_error);
+ if (reply == NULL) {
+ g_warning ("Unable to list sessions: %s", local_error->message);
+ g_error_free (local_error);
+ return FALSE;
+ }
+
+ g_variant_get (reply, "(^ao)", &value);
+ g_variant_unref (reply);
+
+ return value;
+}
+
+static gboolean
+get_login_window_session_id_for_ck (GDBusConnection *connection,
+ const char *seat_id,
+ char **session_id)
+{
+ gboolean can_activate_sessions;
+ const char **sessions;
+ int i;
+
+ *session_id = NULL;
+ sessions = NULL;
+
+ g_debug ("checking if seat can activate sessions");
+
+ can_activate_sessions = seat_can_activate_sessions (connection, seat_id);
+ if (! can_activate_sessions) {
+ g_debug ("seat is unable to activate sessions");
+ return FALSE;
+ }
+
+ sessions = seat_get_sessions (connection, seat_id);
+ for (i = 0; sessions [i] != NULL; i++) {
+ const char *ssid;
+
+ ssid = sessions [i];
+
+ if (session_is_login_window (connection, ssid)) {
+ *session_id = g_strdup (ssid);
+ break;
+ }
+ }
+ g_free (sessions);
+
+ return TRUE;
+}
+
+static gboolean
+goto_login_session_for_ck (GDBusConnection *connection,
+ GCancellable *cancellable,
+ GError **error)
+{
+ gboolean ret;
+ gboolean res;
+ char *session_id;
+ char *seat_id;
+
+ ret = FALSE;
+
+ /* First look for any existing LoginWindow sessions on the seat.
+ If none are found, create a new one. */
+
+ seat_id = get_current_seat_id (connection);
+ if (seat_id == NULL || seat_id[0] == '\0') {
+ g_debug ("seat id is not set; can't switch sessions");
+ g_set_error (error, GDM_CLIENT_ERROR, 0, _("Could not identify the current session."));
+
+ return FALSE;
+ }
+
+ res = get_login_window_session_id_for_ck (connection, seat_id, &session_id);
+ if (! res) {
+ g_set_error (error, GDM_CLIENT_ERROR, 0, _("User unable to switch sessions."));
+ return FALSE;
+ }
+
+ if (session_id != NULL) {
+ res = activate_session_id_for_ck (connection, cancellable, seat_id, session_id, error);
+ if (res) {
+ ret = TRUE;
+ }
+ }
+
+ if (! ret && g_strcmp0 (seat_id, "/org/freedesktop/ConsoleKit/Seat1") == 0) {
+ res = create_transient_display (connection, cancellable, error);
+ if (res) {
+ ret = TRUE;
+ }
+ }
+
+ return ret;
+}
+#endif
+
+#ifdef WITH_SYSTEMD
+
+static gboolean
+activate_session_id_for_systemd (GDBusConnection *connection,
+ GCancellable *cancellable,
+ const char *seat_id,
+ const char *session_id,
+ GError **error)
+{
+ GVariant *reply;
+
+ reply = g_dbus_connection_call_sync (connection,
+ "org.freedesktop.login1",
+ "/org/freedesktop/login1",
+ "org.freedesktop.login1.Manager",
+ "ActivateSessionOnSeat",
+ g_variant_new ("(ss)", session_id, seat_id),
+ NULL,
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ cancellable, error);
+ if (reply == NULL) {
+ g_prefix_error (error, _("Unable to activate session: "));
+ return FALSE;
+ }
+
+ g_variant_unref (reply);
+
+ return TRUE;
+}
+
+static gboolean
+get_login_window_session_id_for_systemd (const char *seat_id,
+ char **session_id)
+{
+ gboolean ret;
+ int res, i;
+ char **sessions;
+ char *service_id;
+ char *service_class;
+ char *state;
+
+ res = sd_seat_get_sessions (seat_id, &sessions, NULL, NULL);
+ if (res < 0) {
+ g_debug ("Failed to determine sessions: %s", strerror (-res));
+ return FALSE;
+ }
+
+ if (sessions == NULL || sessions[0] == NULL) {
+ *session_id = NULL;
+ ret = TRUE;
+ goto out;
+ }
+
+ for (i = 0; sessions[i]; i ++) {
+
+ res = sd_session_get_class (sessions[i], &service_class);
+ if (res < 0) {
+ g_debug ("failed to determine class of session %s: %s", sessions[i], strerror (-res));
+ ret = FALSE;
+ goto out;
+ }
+
+ if (strcmp (service_class, "greeter") != 0) {
+ free (service_class);
+ continue;
+ }
+
+ free (service_class);
+
+ ret = sd_session_get_state (sessions[i], &state);
+ if (ret < 0) {
+ g_debug ("failed to determine state of session %s: %s", sessions[i], strerror (-res));
+ ret = FALSE;
+ goto out;
+ }
+
+ if (g_strcmp0 (state, "closing") == 0) {
+ free (state);
+ continue;
+ }
+ free (state);
+
+ res = sd_session_get_service (sessions[i], &service_id);
+ if (res < 0) {
+ g_debug ("failed to determine service of session %s: %s", sessions[i], strerror (-res));
+ ret = FALSE;
+ goto out;
+ }
+
+ if (strcmp (service_id, "gdm-launch-environment") == 0) {
+ *session_id = g_strdup (sessions[i]);
+ ret = TRUE;
+
+ free (service_id);
+ goto out;
+ }
+
+ free (service_id);
+ }
+
+ *session_id = NULL;
+ ret = TRUE;
+
+out:
+ if (sessions) {
+ for (i = 0; sessions[i]; i ++) {
+ free (sessions[i]);
+ }
+
+ free (sessions);
+ }
+
+ return ret;
+}
+
+static gboolean
+goto_login_session_for_systemd (GDBusConnection *connection,
+ GCancellable *cancellable,
+ GError **error)
+{
+ gboolean ret;
+ int res;
+ char *our_session;
+ char *session_id;
+ char *seat_id;
+
+ ret = FALSE;
+ session_id = NULL;
+ seat_id = NULL;
+
+ /* First look for any existing LoginWindow sessions on the seat.
+ If none are found, create a new one. */
+
+ /* Note that we mostly use free () here, instead of g_free ()
+ * since the data allocated is from libsystemd-logind, which
+ * does not use GLib's g_malloc (). */
+
+ res = sd_pid_get_session (0, &our_session);
+ if (res < 0) {
+ g_debug ("failed to determine own session: %s", strerror (-res));
+ g_set_error (error, GDM_CLIENT_ERROR, 0, _("Could not identify the current session."));
+
+ return FALSE;
+ }
+
+ res = sd_session_get_seat (our_session, &seat_id);
+ free (our_session);
+ if (res < 0) {
+ g_debug ("failed to determine own seat: %s", strerror (-res));
+ g_set_error (error, GDM_CLIENT_ERROR, 0, _("Could not identify the current seat."));
+
+ return FALSE;
+ }
+
+ res = sd_seat_can_multi_session (seat_id);
+ if (res < 0) {
+ free (seat_id);
+
+ g_debug ("failed to determine whether seat can do multi session: %s", strerror (-res));
+ g_set_error (error, GDM_CLIENT_ERROR, 0, _("The system is unable to determine whether to switch to an existing login screen or start up a new login screen."));
+
+ return FALSE;
+ }
+
+ if (res == 0) {
+ free (seat_id);
+
+ g_set_error (error, GDM_CLIENT_ERROR, 0, _("The system is unable to start up a new login screen."));
+
+ return FALSE;
+ }
+
+ res = get_login_window_session_id_for_systemd (seat_id, &session_id);
+ if (res && session_id != NULL) {
+ res = activate_session_id_for_systemd (connection, cancellable, seat_id, session_id, error);
+
+ if (res) {
+ ret = TRUE;
+ }
+ }
+
+ if (! ret && g_strcmp0 (seat_id, "seat0") == 0) {
+ res = create_transient_display (connection, cancellable, error);
+ if (res) {
+ ret = TRUE;
+ }
+ }
+
+ free (seat_id);
+ g_free (session_id);
+
+ return ret;
+}
+#endif
+
+gboolean
+gdm_goto_login_session_sync (GCancellable *cancellable,
+ GError **error)
+{
+ GDBusConnection *connection;
+ gboolean retval;
+
+ connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, cancellable, error);
+ if (!connection)
+ return FALSE;
+
+#ifdef WITH_SYSTEMD
+ if (LOGIND_RUNNING()) {
+ retval = goto_login_session_for_systemd (connection,
+ cancellable,
+ error);
+
+ g_object_unref (connection);
+ return retval;
+ }
+#endif
+
+#ifdef WITH_CONSOLE_KIT
+ retval = goto_login_session_for_ck (connection, cancellable, error);
+
+ g_object_unref (connection);
+ return retval;
+#endif
+}
diff --git a/libgdm/gdm-user-switching.h b/libgdm/gdm-user-switching.h
new file mode 100644
index 00000000..2886d503
--- /dev/null
+++ b/libgdm/gdm-user-switching.h
@@ -0,0 +1,31 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ * Copyright (C) 2012 Giovanni Campagna <scampa.giovanni@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef __GDM_USER_SWITCHING_H
+#define __GDM_USER_SWITCHING_H
+
+#include <glib-object.h>
+#include <gio/gio.h>
+
+gboolean gdm_goto_login_session_sync (GCancellable *cancellable,
+ GError **error);
+
+#endif
diff --git a/libgdm/gdm.pc.in b/libgdm/gdm.pc.in
new file mode 100644
index 00000000..9570d8c5
--- /dev/null
+++ b/libgdm/gdm.pc.in
@@ -0,0 +1,10 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: GDM Client Library
+Description: Client Library for communicating with GDM daemon
+Version: @VERSION@
+Libs: -L${libdir} -lgdm
+Cflags: -I${includedir}/gdm
View Lorry Controller Status