From af4e5855a22af0774f734b2b86ce7afc0a84e6e1 Mon Sep 17 00:00:00 2001 From: Ray Strode Date: Mon, 16 Dec 2013 10:52:34 -0500 Subject: 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. --- libgdm/Makefile.am | 121 ++++ libgdm/gdm-client.c | 1445 +++++++++++++++++++++++++++++++++++++++++++ libgdm/gdm-client.h | 123 ++++ libgdm/gdm-sessions.c | 280 +++++++++ libgdm/gdm-sessions.h | 37 ++ libgdm/gdm-user-switching.c | 597 ++++++++++++++++++ libgdm/gdm-user-switching.h | 31 + libgdm/gdm.pc.in | 10 + 8 files changed, 2644 insertions(+) create mode 100644 libgdm/Makefile.am create mode 100644 libgdm/gdm-client.c create mode 100644 libgdm/gdm-client.h create mode 100644 libgdm/gdm-sessions.c create mode 100644 libgdm/gdm-sessions.h create mode 100644 libgdm/gdm-user-switching.c create mode 100644 libgdm/gdm-user-switching.h create mode 100644 libgdm/gdm.pc.in (limited to 'libgdm') 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 + * + * 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 +#include +#include +#include + +#include +#include +#include + +#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 + * + * 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 +#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 + * + * 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 + * Ray Strode + */ + +#include "config.h" + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#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 + * + * 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 + +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 + * + * 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 +#include +#include +#include + +#include +#include +#include +#include + +#ifdef WITH_SYSTEMD +#include +#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 + * + * 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 +#include + +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 -- cgit v1.2.1