moving from https://github.com/perberos/mate-desktop-environment

1 files changed, 1332 insertions, 0 deletions

diff --git a/mate-session/gsm-xsmp-client.c b/mate-session/gsm-xsmp-client.c
new file mode 100644
index 0000000..ce0c92f
--- /dev/null
+++ b/mate-session/gsm-xsmp-client.c
@@ -0,0 +1,1332 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2007 Novell, Inc.
+ * Copyright (C) 2008 Red Hat, Inc.
+ *
+ * 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
+ * Lesser 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., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include "config.h"
+
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include <gio/gio.h>
+#include <glib/gi18n.h>
+
+#include "gsm-xsmp-client.h"
+#include "gsm-marshal.h"
+
+#include "gsm-util.h"
+#include "gsm-autostart-app.h"
+#include "gsm-manager.h"
+
+#define GsmDesktopFile "_GSM_DesktopFile"
+
+#define IS_STRING_EMPTY(x) ((x)==NULL||(x)[0]=='\0')
+
+#define GSM_XSMP_CLIENT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GSM_TYPE_XSMP_CLIENT, GsmXSMPClientPrivate))
+
+struct GsmXSMPClientPrivate
+{
+
+        SmsConn    conn;
+        IceConn    ice_connection;
+
+        guint      watch_id;
+
+        char      *description;
+        GPtrArray *props;
+
+        /* SaveYourself state */
+        int        current_save_yourself;
+        int        next_save_yourself;
+        guint      next_save_yourself_allow_interact : 1;
+};
+
+enum {
+        PROP_0,
+        PROP_ICE_CONNECTION
+};
+
+enum {
+        REGISTER_REQUEST,
+        LOGOUT_REQUEST,
+        LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0 };
+
+G_DEFINE_TYPE (GsmXSMPClient, gsm_xsmp_client, GSM_TYPE_CLIENT)
+
+static gboolean
+client_iochannel_watch (GIOChannel    *channel,
+                        GIOCondition   condition,
+                        GsmXSMPClient *client)
+{
+        gboolean keep_going;
+
+        g_object_ref (client);
+        switch (IceProcessMessages (client->priv->ice_connection, NULL, NULL)) {
+        case IceProcessMessagesSuccess:
+                keep_going = TRUE;
+                break;
+
+        case IceProcessMessagesIOError:
+                g_debug ("GsmXSMPClient: IceProcessMessagesIOError on '%s'", client->priv->description);
+                gsm_client_set_status (GSM_CLIENT (client), GSM_CLIENT_FAILED);
+                /* Emitting "disconnected" will eventually cause
+                 * IceCloseConnection() to be called.
+                 */
+                gsm_client_disconnected (GSM_CLIENT (client));
+                keep_going = FALSE;
+                break;
+
+        case IceProcessMessagesConnectionClosed:
+                g_debug ("GsmXSMPClient: IceProcessMessagesConnectionClosed on '%s'",
+                         client->priv->description);
+                client->priv->ice_connection = NULL;
+                keep_going = FALSE;
+                break;
+
+        default:
+                g_assert_not_reached ();
+        }
+        g_object_unref (client);
+
+        return keep_going;
+}
+
+static SmProp *
+find_property (GsmXSMPClient *client,
+               const char    *name,
+               int           *index)
+{
+        SmProp *prop;
+        int i;
+
+        for (i = 0; i < client->priv->props->len; i++) {
+                prop = client->priv->props->pdata[i];
+
+                if (!strcmp (prop->name, name)) {
+                        if (index) {
+                                *index = i;
+                        }
+                        return prop;
+                }
+        }
+
+        return NULL;
+}
+
+static void
+set_description (GsmXSMPClient *client)
+{
+        SmProp     *prop;
+        const char *id;
+
+        prop = find_property (client, SmProgram, NULL);
+        id = gsm_client_peek_startup_id (GSM_CLIENT (client));
+
+        g_free (client->priv->description);
+        if (prop) {
+                client->priv->description = g_strdup_printf ("%p [%.*s %s]",
+                                                             client,
+                                                             prop->vals[0].length,
+                                                             (char *)prop->vals[0].value,
+                                                             id);
+        } else if (id != NULL) {
+                client->priv->description = g_strdup_printf ("%p [%s]", client, id);
+        } else {
+                client->priv->description = g_strdup_printf ("%p", client);
+        }
+}
+
+static void
+setup_connection (GsmXSMPClient *client)
+{
+        GIOChannel    *channel;
+        int            fd;
+
+        g_debug ("GsmXSMPClient: Setting up new connection");
+
+        fd = IceConnectionNumber (client->priv->ice_connection);
+        fcntl (fd, F_SETFD, fcntl (fd, F_GETFD, 0) | FD_CLOEXEC);
+        channel = g_io_channel_unix_new (fd);
+        client->priv->watch_id = g_io_add_watch (channel,
+                                                 G_IO_IN | G_IO_ERR,
+                                                 (GIOFunc)client_iochannel_watch,
+                                                 client);
+        g_io_channel_unref (channel);
+
+        set_description (client);
+
+        g_debug ("GsmXSMPClient: New client '%s'", client->priv->description);
+}
+
+static GObject *
+gsm_xsmp_client_constructor (GType                  type,
+                             guint                  n_construct_properties,
+                             GObjectConstructParam *construct_properties)
+{
+        GsmXSMPClient *client;
+
+        client = GSM_XSMP_CLIENT (G_OBJECT_CLASS (gsm_xsmp_client_parent_class)->constructor (type,
+                                                                                              n_construct_properties,
+                                                                                              construct_properties));
+        setup_connection (client);
+
+        return G_OBJECT (client);
+}
+
+static void
+gsm_xsmp_client_init (GsmXSMPClient *client)
+{
+        client->priv = GSM_XSMP_CLIENT_GET_PRIVATE (client);
+
+        client->priv->props = g_ptr_array_new ();
+        client->priv->current_save_yourself = -1;
+        client->priv->next_save_yourself = -1;
+        client->priv->next_save_yourself_allow_interact = FALSE;
+}
+
+
+static void
+delete_property (GsmXSMPClient *client,
+                 const char    *name)
+{
+        int     index;
+        SmProp *prop;
+
+        prop = find_property (client, name, &index);
+        if (!prop) {
+                return;
+        }
+
+#if 0
+        /* This is wrong anyway; we can't unconditionally run the current
+         * discard command; if this client corresponds to a GsmAppResumed,
+         * and the current discard command is identical to the app's
+         * discard_command, then we don't run the discard command now,
+         * because that would delete a saved state we may want to resume
+         * again later.
+         */
+        if (!strcmp (name, SmDiscardCommand)) {
+                gsm_client_run_discard (GSM_CLIENT (client));
+        }
+#endif
+
+        g_ptr_array_remove_index_fast (client->priv->props, index);
+        SmFreeProperty (prop);
+}
+
+
+static void
+debug_print_property (SmProp *prop)
+{
+        GString *tmp;
+        int      i;
+
+        switch (prop->type[0]) {
+        case 'C': /* CARD8 */
+                g_debug ("GsmXSMPClient:   %s = %d", prop->name, *(unsigned char *)prop->vals[0].value);
+                break;
+
+        case 'A': /* ARRAY8 */
+                g_debug ("GsmXSMPClient:   %s = '%s'", prop->name, (char *)prop->vals[0].value);
+                break;
+
+        case 'L': /* LISTofARRAY8 */
+                tmp = g_string_new (NULL);
+                for (i = 0; i < prop->num_vals; i++) {
+                        g_string_append_printf (tmp, "'%.*s' ", prop->vals[i].length,
+                                                (char *)prop->vals[i].value);
+                }
+                g_debug ("GsmXSMPClient:   %s = %s", prop->name, tmp->str);
+                g_string_free (tmp, TRUE);
+                break;
+
+        default:
+                g_debug ("GsmXSMPClient:   %s = ??? (%s)", prop->name, prop->type);
+                break;
+        }
+}
+
+
+static void
+set_properties_callback (SmsConn     conn,
+                         SmPointer   manager_data,
+                         int         num_props,
+                         SmProp    **props)
+{
+        GsmXSMPClient *client = manager_data;
+        int            i;
+
+        g_debug ("GsmXSMPClient: Set properties from client '%s'", client->priv->description);
+
+        for (i = 0; i < num_props; i++) {
+                delete_property (client, props[i]->name);
+                g_ptr_array_add (client->priv->props, props[i]);
+
+                debug_print_property (props[i]);
+
+                if (!strcmp (props[i]->name, SmProgram))
+                        set_description (client);
+        }
+
+        free (props);
+
+}
+
+static void
+delete_properties_callback (SmsConn     conn,
+                            SmPointer   manager_data,
+                            int         num_props,
+                            char      **prop_names)
+{
+        GsmXSMPClient *client = manager_data;
+        int i;
+
+        g_debug ("GsmXSMPClient: Delete properties from '%s'", client->priv->description);
+
+        for (i = 0; i < num_props; i++) {
+                delete_property (client, prop_names[i]);
+
+                g_debug ("  %s", prop_names[i]);
+        }
+
+        free (prop_names);
+}
+
+static void
+get_properties_callback (SmsConn   conn,
+                         SmPointer manager_data)
+{
+        GsmXSMPClient *client = manager_data;
+
+        g_debug ("GsmXSMPClient: Get properties request from '%s'", client->priv->description);
+
+        SmsReturnProperties (conn,
+                             client->priv->props->len,
+                             (SmProp **)client->priv->props->pdata);
+}
+
+static char *
+prop_to_command (SmProp *prop)
+{
+        GString *str;
+        int i, j;
+        gboolean need_quotes;
+
+        str = g_string_new (NULL);
+        for (i = 0; i < prop->num_vals; i++) {
+                char *val = prop->vals[i].value;
+
+                need_quotes = FALSE;
+                for (j = 0; j < prop->vals[i].length; j++) {
+                        if (!g_ascii_isalnum (val[j]) && !strchr ("-_=:./", val[j])) {
+                                need_quotes = TRUE;
+                                break;
+                        }
+                }
+
+                if (i > 0) {
+                        g_string_append_c (str, ' ');
+                }
+
+                if (!need_quotes) {
+                        g_string_append_printf (str,
+                                                "%.*s",
+                                                prop->vals[i].length,
+                                                (char *)prop->vals[i].value);
+                } else {
+                        g_string_append_c (str, '\'');
+                        while (val < (char *)prop->vals[i].value + prop->vals[i].length) {
+                                if (*val == '\'') {
+                                        g_string_append (str, "'\''");
+                                } else {
+                                        g_string_append_c (str, *val);
+                                }
+                                val++;
+                        }
+                        g_string_append_c (str, '\'');
+                }
+        }
+
+        return g_string_free (str, FALSE);
+}
+
+static char *
+xsmp_get_restart_command (GsmClient *client)
+{
+        SmProp *prop;
+
+        prop = find_property (GSM_XSMP_CLIENT (client), SmRestartCommand, NULL);
+
+        if (!prop || strcmp (prop->type, SmLISTofARRAY8) != 0) {
+                return NULL;
+        }
+
+        return prop_to_command (prop);
+}
+
+static char *
+xsmp_get_discard_command (GsmClient *client)
+{
+        SmProp *prop;
+
+        prop = find_property (GSM_XSMP_CLIENT (client), SmDiscardCommand, NULL);
+
+        if (!prop || strcmp (prop->type, SmLISTofARRAY8) != 0) {
+                return NULL;
+        }
+
+        return prop_to_command (prop);
+}
+
+static void
+do_save_yourself (GsmXSMPClient *client,
+                  int            save_type,
+                  gboolean       allow_interact)
+{
+        g_assert (client->priv->conn != NULL);
+
+        if (client->priv->next_save_yourself != -1) {
+                /* Either we're currently doing a shutdown and there's a checkpoint
+                 * queued after it, or vice versa. Either way, the new SaveYourself
+                 * is redundant.
+                 */
+                g_debug ("GsmXSMPClient:   skipping redundant SaveYourself for '%s'",
+                         client->priv->description);
+        } else if (client->priv->current_save_yourself != -1) {
+                g_debug ("GsmXSMPClient:   queuing new SaveYourself for '%s'",
+                         client->priv->description);
+                client->priv->next_save_yourself = save_type;
+                client->priv->next_save_yourself_allow_interact = allow_interact;
+        } else {
+                client->priv->current_save_yourself = save_type;
+                /* make sure we don't have anything queued */
+                client->priv->next_save_yourself = -1;
+                client->priv->next_save_yourself_allow_interact = FALSE;
+
+                switch (save_type) {
+                case SmSaveLocal:
+                        /* Save state */
+                        SmsSaveYourself (client->priv->conn,
+                                         SmSaveLocal,
+                                         FALSE,
+                                         SmInteractStyleNone,
+                                         FALSE);
+                        break;
+
+                default:
+                        /* Logout */
+                        if (!allow_interact) {
+                                SmsSaveYourself (client->priv->conn,
+                                                 save_type, /* save type */
+                                                 TRUE, /* shutdown */
+                                                 SmInteractStyleNone, /* interact style */
+                                                 TRUE); /* fast */
+                        } else {
+                                SmsSaveYourself (client->priv->conn,
+                                                 save_type, /* save type */
+                                                 TRUE, /* shutdown */
+                                                 SmInteractStyleAny, /* interact style */
+                                                 FALSE /* fast */);
+                        }
+                        break;
+                }
+        }
+}
+
+static void
+xsmp_save_yourself_phase2 (GsmClient *client)
+{
+        GsmXSMPClient *xsmp = (GsmXSMPClient *) client;
+
+        g_debug ("GsmXSMPClient: xsmp_save_yourself_phase2 ('%s')", xsmp->priv->description);
+
+        SmsSaveYourselfPhase2 (xsmp->priv->conn);
+}
+
+static void
+xsmp_interact (GsmClient *client)
+{
+        GsmXSMPClient *xsmp = (GsmXSMPClient *) client;
+
+        g_debug ("GsmXSMPClient: xsmp_interact ('%s')", xsmp->priv->description);
+
+        SmsInteract (xsmp->priv->conn);
+}
+
+static gboolean
+xsmp_cancel_end_session (GsmClient *client,
+                         GError   **error)
+{
+        GsmXSMPClient *xsmp = (GsmXSMPClient *) client;
+
+        g_debug ("GsmXSMPClient: xsmp_cancel_end_session ('%s')", xsmp->priv->description);
+
+        if (xsmp->priv->conn == NULL) {
+                g_set_error (error,
+                             GSM_CLIENT_ERROR,
+                             GSM_CLIENT_ERROR_NOT_REGISTERED,
+                             "Client is not registered");
+                return FALSE;
+        }
+
+        SmsShutdownCancelled (xsmp->priv->conn);
+
+        /* reset the state */
+        xsmp->priv->current_save_yourself = -1;
+        xsmp->priv->next_save_yourself = -1;
+        xsmp->priv->next_save_yourself_allow_interact = FALSE;
+
+        return TRUE;
+}
+
+static char *
+get_desktop_file_path (GsmXSMPClient *client)
+{
+        SmProp     *prop;
+        char       *desktop_file_path = NULL;
+        char      **dirs;
+        const char *program_name;
+
+        /* XSMP clients using eggsmclient defines a special property
+         * pointing to their respective desktop entry file */
+        prop = find_property (client, GsmDesktopFile, NULL);
+
+        if (prop) {
+                GFile *file = g_file_new_for_uri (prop->vals[0].value);
+                desktop_file_path = g_file_get_path (file);
+                g_object_unref (file);
+                goto out;
+        }
+
+        /* If we can't get desktop file from GsmDesktopFile then we
+         * try to find the desktop file from its program name */
+        prop = find_property (client, SmProgram, NULL);
+        program_name = prop->vals[0].value;
+
+        dirs = gsm_util_get_autostart_dirs ();
+
+        desktop_file_path =
+                gsm_util_find_desktop_file_for_app_name (program_name,
+                                                         dirs);
+
+        g_strfreev (dirs);
+
+out:
+        g_debug ("GsmXSMPClient: desktop file for client %s is %s",
+                 gsm_client_peek_id (GSM_CLIENT (client)),
+                 desktop_file_path ? desktop_file_path : "(null)");
+
+        return desktop_file_path;
+}
+
+static void
+set_desktop_file_keys_from_client (GsmClient *client,
+                                   GKeyFile  *keyfile)
+{
+        SmProp *prop;
+        char   *name;
+        char   *comment;
+
+        prop = find_property (GSM_XSMP_CLIENT (client), SmProgram, NULL);
+        name = g_strdup (prop->vals[0].value);
+
+        comment = g_strdup_printf ("Client %s which was automatically saved",
+                                   gsm_client_peek_startup_id (client));
+
+        g_key_file_set_string (keyfile,
+                               G_KEY_FILE_DESKTOP_GROUP,
+                               G_KEY_FILE_DESKTOP_KEY_NAME,
+                               name);
+
+        g_key_file_set_string (keyfile,
+                               G_KEY_FILE_DESKTOP_GROUP,
+                               G_KEY_FILE_DESKTOP_KEY_COMMENT,
+                               comment);
+
+        g_key_file_set_string (keyfile,
+                               G_KEY_FILE_DESKTOP_GROUP,
+                               G_KEY_FILE_DESKTOP_KEY_ICON,
+                               "system-run");
+
+        g_key_file_set_string (keyfile,
+                               G_KEY_FILE_DESKTOP_GROUP,
+                               G_KEY_FILE_DESKTOP_KEY_TYPE,
+                               "Application");
+
+        g_key_file_set_boolean (keyfile,
+                                G_KEY_FILE_DESKTOP_GROUP,
+                                G_KEY_FILE_DESKTOP_KEY_STARTUP_NOTIFY,
+                                TRUE);
+
+        g_free (name);
+        g_free (comment);
+}
+
+static GKeyFile *
+create_client_key_file (GsmClient   *client,
+                        const char  *desktop_file_path,
+                        GError     **error) {
+        GKeyFile *keyfile;
+
+        keyfile = g_key_file_new ();
+
+        if (desktop_file_path != NULL) {
+                g_key_file_load_from_file (keyfile,
+                                           desktop_file_path,
+                                           G_KEY_FILE_KEEP_COMMENTS |
+                                           G_KEY_FILE_KEEP_TRANSLATIONS,
+                                           error);
+        } else {
+                set_desktop_file_keys_from_client (client, keyfile);
+        }
+
+        return keyfile;
+}
+
+static GsmClientRestartStyle
+xsmp_get_restart_style_hint (GsmClient *client);
+
+static GKeyFile *
+xsmp_save (GsmClient *client,
+           GError   **error)
+{
+        GsmClientRestartStyle restart_style;
+
+        GKeyFile *keyfile = NULL;
+        char     *desktop_file_path = NULL;
+        char     *exec_program = NULL;
+        char     *exec_discard = NULL;
+        char     *startup_id = NULL;
+        GError   *local_error;
+
+        g_debug ("GsmXSMPClient: saving client with id %s",
+                 gsm_client_peek_id (client));
+
+        local_error = NULL;
+
+        restart_style = xsmp_get_restart_style_hint (client);
+        if (restart_style == GSM_CLIENT_RESTART_NEVER) {
+                goto out;
+        }
+
+        exec_program = xsmp_get_restart_command (client);
+        if (!exec_program) {
+                goto out;
+        }
+
+        desktop_file_path = get_desktop_file_path (GSM_XSMP_CLIENT (client));
+
+        keyfile = create_client_key_file (client,
+                                          desktop_file_path,
+                                          &local_error);
+
+        if (local_error) {
+                goto out;
+        }
+
+        g_object_get (client,
+                      "startup-id", &startup_id,
+                      NULL);
+
+        g_key_file_set_string (keyfile,
+                               G_KEY_FILE_DESKTOP_GROUP,
+                               GSM_AUTOSTART_APP_STARTUP_ID_KEY,
+                               startup_id);
+
+        g_key_file_set_string (keyfile,
+                               G_KEY_FILE_DESKTOP_GROUP,
+                               G_KEY_FILE_DESKTOP_KEY_EXEC,
+                               exec_program);
+
+        exec_discard = xsmp_get_discard_command (client);
+        if (exec_discard)
+                g_key_file_set_string (keyfile,
+                                       G_KEY_FILE_DESKTOP_GROUP,
+                                       GSM_AUTOSTART_APP_DISCARD_KEY,
+                                       exec_discard);
+
+out:
+        g_free (desktop_file_path);
+        g_free (exec_program);
+        g_free (exec_discard);
+        g_free (startup_id);
+
+        if (local_error != NULL) {
+                g_propagate_error (error, local_error);
+                g_key_file_free (keyfile);
+
+                return NULL;
+        }
+
+        return keyfile;
+}
+
+static gboolean
+xsmp_stop (GsmClient *client,
+           GError   **error)
+{
+        GsmXSMPClient *xsmp = (GsmXSMPClient *) client;
+
+        g_debug ("GsmXSMPClient: xsmp_stop ('%s')", xsmp->priv->description);
+
+        if (xsmp->priv->conn == NULL) {
+                g_set_error (error,
+                             GSM_CLIENT_ERROR,
+                             GSM_CLIENT_ERROR_NOT_REGISTERED,
+                             "Client is not registered");
+                return FALSE;
+        }
+
+        SmsDie (xsmp->priv->conn);
+
+        return TRUE;
+}
+
+static gboolean
+xsmp_query_end_session (GsmClient *client,
+                        guint      flags,
+                        GError   **error)
+{
+        gboolean allow_interact;
+        int      save_type;
+
+        if (GSM_XSMP_CLIENT (client)->priv->conn == NULL) {
+                g_set_error (error,
+                             GSM_CLIENT_ERROR,
+                             GSM_CLIENT_ERROR_NOT_REGISTERED,
+                             "Client is not registered");
+                return FALSE;
+        }
+
+        allow_interact = !(flags & GSM_CLIENT_END_SESSION_FLAG_FORCEFUL);
+
+        /* we don't want to save the session state, but we just want to know if
+         * there's user data the client has to save and we want to give the
+         * client a chance to tell the user about it. This is consistent with
+         * the manager not setting GSM_CLIENT_END_SESSION_FLAG_SAVE for this
+         * phase. */
+        save_type = SmSaveGlobal;
+
+        do_save_yourself (GSM_XSMP_CLIENT (client), save_type, allow_interact);
+        return TRUE;
+}
+
+static gboolean
+xsmp_end_session (GsmClient *client,
+                  guint      flags,
+                  GError   **error)
+{
+        gboolean phase2;
+
+        if (GSM_XSMP_CLIENT (client)->priv->conn == NULL) {
+                g_set_error (error,
+                             GSM_CLIENT_ERROR,
+                             GSM_CLIENT_ERROR_NOT_REGISTERED,
+                             "Client is not registered");
+                return FALSE;
+        }
+
+        phase2 = (flags & GSM_CLIENT_END_SESSION_FLAG_LAST);
+
+        if (phase2) {
+                xsmp_save_yourself_phase2 (client);
+        } else {
+                gboolean allow_interact;
+                int      save_type;
+
+                /* we gave a chance to interact to the app during
+                 * xsmp_query_end_session(), now it's too late to interact */
+                allow_interact = FALSE;
+
+                if (flags & GSM_CLIENT_END_SESSION_FLAG_SAVE) {
+                        save_type = SmSaveBoth;
+                } else {
+                        save_type = SmSaveGlobal;
+                }
+
+                do_save_yourself (GSM_XSMP_CLIENT (client),
+                                  save_type, allow_interact);
+        }
+
+        return TRUE;
+}
+
+static char *
+xsmp_get_app_name (GsmClient *client)
+{
+        SmProp *prop;
+        char   *name;
+
+        prop = find_property (GSM_XSMP_CLIENT (client), SmProgram, NULL);
+        name = prop_to_command (prop);
+
+        return name;
+}
+
+static void
+gsm_client_set_ice_connection (GsmXSMPClient *client,
+                               gpointer       conn)
+{
+        client->priv->ice_connection = conn;
+}
+
+static void
+gsm_xsmp_client_set_property (GObject       *object,
+                              guint          prop_id,
+                              const GValue  *value,
+                              GParamSpec    *pspec)
+{
+        GsmXSMPClient *self;
+
+        self = GSM_XSMP_CLIENT (object);
+
+        switch (prop_id) {
+        case PROP_ICE_CONNECTION:
+                gsm_client_set_ice_connection (self, g_value_get_pointer (value));
+                break;
+        default:
+                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+                break;
+        }
+}
+
+static void
+gsm_xsmp_client_get_property (GObject    *object,
+                              guint       prop_id,
+                              GValue     *value,
+                              GParamSpec *pspec)
+{
+        GsmXSMPClient *self;
+
+        self = GSM_XSMP_CLIENT (object);
+
+        switch (prop_id) {
+        case PROP_ICE_CONNECTION:
+                g_value_set_pointer (value, self->priv->ice_connection);
+                break;
+        default:
+                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+                break;
+        }
+}
+
+static void
+gsm_xsmp_client_disconnect (GsmXSMPClient *client)
+{
+        if (client->priv->watch_id > 0) {
+                g_source_remove (client->priv->watch_id);
+        }
+
+        if (client->priv->conn != NULL) {
+                SmsCleanUp (client->priv->conn);
+        }
+
+        if (client->priv->ice_connection != NULL) {
+                IceSetShutdownNegotiation (client->priv->ice_connection, FALSE);
+                IceCloseConnection (client->priv->ice_connection);
+        }
+}
+
+static void
+gsm_xsmp_client_finalize (GObject *object)
+{
+        GsmXSMPClient *client = (GsmXSMPClient *) object;
+
+        g_debug ("GsmXSMPClient: xsmp_finalize (%s)", client->priv->description);
+        gsm_xsmp_client_disconnect (client);
+
+        g_free (client->priv->description);
+        g_ptr_array_foreach (client->priv->props, (GFunc)SmFreeProperty, NULL);
+        g_ptr_array_free (client->priv->props, TRUE);
+
+        G_OBJECT_CLASS (gsm_xsmp_client_parent_class)->finalize (object);
+}
+
+static gboolean
+_boolean_handled_accumulator (GSignalInvocationHint *ihint,
+                              GValue                *return_accu,
+                              const GValue          *handler_return,
+                              gpointer               dummy)
+{
+        gboolean    continue_emission;
+        gboolean    signal_handled;
+
+        signal_handled = g_value_get_boolean (handler_return);
+        g_value_set_boolean (return_accu, signal_handled);
+        continue_emission = !signal_handled;
+
+        return continue_emission;
+}
+
+static GsmClientRestartStyle
+xsmp_get_restart_style_hint (GsmClient *client)
+{
+        SmProp               *prop;
+        GsmClientRestartStyle hint;
+
+        g_debug ("GsmXSMPClient: getting restart style");
+        hint = GSM_CLIENT_RESTART_IF_RUNNING;
+
+        prop = find_property (GSM_XSMP_CLIENT (client), SmRestartStyleHint, NULL);
+
+        if (!prop || strcmp (prop->type, SmCARD8) != 0) {
+                return GSM_CLIENT_RESTART_IF_RUNNING;
+        }
+
+        switch (((unsigned char *)prop->vals[0].value)[0]) {
+        case SmRestartIfRunning:
+                hint = GSM_CLIENT_RESTART_IF_RUNNING;
+                break;
+        case SmRestartAnyway:
+                hint = GSM_CLIENT_RESTART_ANYWAY;
+                break;
+        case SmRestartImmediately:
+                hint = GSM_CLIENT_RESTART_IMMEDIATELY;
+                break;
+        case SmRestartNever:
+                hint = GSM_CLIENT_RESTART_NEVER;
+                break;
+        default:
+                break;
+        }
+
+        return hint;
+}
+
+static gboolean
+_parse_value_as_uint (const char *value,
+                      guint      *uintval)
+{
+        char  *end_of_valid_uint;
+        gulong ulong_value;
+        guint  uint_value;
+
+        errno = 0;
+        ulong_value = strtoul (value, &end_of_valid_uint, 10);
+
+        if (*value == '\0' || *end_of_valid_uint != '\0') {
+                return FALSE;
+        }
+
+        uint_value = ulong_value;
+        if (uint_value != ulong_value || errno == ERANGE) {
+                return FALSE;
+        }
+
+        *uintval = uint_value;
+
+        return TRUE;
+}
+
+static guint
+xsmp_get_unix_process_id (GsmClient *client)
+{
+        SmProp  *prop;
+        guint    pid;
+        gboolean res;
+
+        g_debug ("GsmXSMPClient: getting pid");
+
+        prop = find_property (GSM_XSMP_CLIENT (client), SmProcessID, NULL);
+
+        if (!prop || strcmp (prop->type, SmARRAY8) != 0) {
+                return 0;
+        }
+
+        pid = 0;
+        res = _parse_value_as_uint ((char *)prop->vals[0].value, &pid);
+        if (! res) {
+                pid = 0;
+        }
+
+        return pid;
+}
+
+static void
+gsm_xsmp_client_class_init (GsmXSMPClientClass *klass)
+{
+        GObjectClass   *object_class = G_OBJECT_CLASS (klass);
+        GsmClientClass *client_class = GSM_CLIENT_CLASS (klass);
+
+        object_class->finalize             = gsm_xsmp_client_finalize;
+        object_class->constructor          = gsm_xsmp_client_constructor;
+        object_class->get_property         = gsm_xsmp_client_get_property;
+        object_class->set_property         = gsm_xsmp_client_set_property;
+
+        client_class->impl_save                   = xsmp_save;
+        client_class->impl_stop                   = xsmp_stop;
+        client_class->impl_query_end_session      = xsmp_query_end_session;
+        client_class->impl_end_session            = xsmp_end_session;
+        client_class->impl_cancel_end_session     = xsmp_cancel_end_session;
+        client_class->impl_get_app_name           = xsmp_get_app_name;
+        client_class->impl_get_restart_style_hint = xsmp_get_restart_style_hint;
+        client_class->impl_get_unix_process_id    = xsmp_get_unix_process_id;
+
+        signals[REGISTER_REQUEST] =
+                g_signal_new ("register-request",
+                              G_OBJECT_CLASS_TYPE (object_class),
+                              G_SIGNAL_RUN_LAST,
+                              G_STRUCT_OFFSET (GsmXSMPClientClass, register_request),
+                              _boolean_handled_accumulator,
+                              NULL,
+                              gsm_marshal_BOOLEAN__POINTER,
+                              G_TYPE_BOOLEAN,
+                              1, G_TYPE_POINTER);
+        signals[LOGOUT_REQUEST] =
+                g_signal_new ("logout-request",
+                              G_OBJECT_CLASS_TYPE (object_class),
+                              G_SIGNAL_RUN_LAST,
+                              G_STRUCT_OFFSET (GsmXSMPClientClass, logout_request),
+                              NULL,
+                              NULL,
+                              g_cclosure_marshal_VOID__BOOLEAN,
+                              G_TYPE_NONE,
+                              1, G_TYPE_BOOLEAN);
+
+        g_object_class_install_property (object_class,
+                                         PROP_ICE_CONNECTION,
+                                         g_param_spec_pointer ("ice-connection",
+                                                               "ice-connection",
+                                                               "ice-connection",
+                                                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+
+        g_type_class_add_private (klass, sizeof (GsmXSMPClientPrivate));
+}
+
+GsmClient *
+gsm_xsmp_client_new (IceConn ice_conn)
+{
+        GsmXSMPClient *xsmp;
+
+        xsmp = g_object_new (GSM_TYPE_XSMP_CLIENT,
+                             "ice-connection", ice_conn,
+                             NULL);
+
+        return GSM_CLIENT (xsmp);
+}
+
+static Status
+register_client_callback (SmsConn    conn,
+                          SmPointer  manager_data,
+                          char      *previous_id)
+{
+        GsmXSMPClient *client = manager_data;
+        gboolean       handled;
+        char          *id;
+
+        g_debug ("GsmXSMPClient: Client '%s' received RegisterClient(%s)",
+                 client->priv->description,
+                 previous_id ? previous_id : "NULL");
+
+
+        /* There are three cases:
+         * 1. id is NULL - we'll use a new one
+         * 2. id is known - we'll use known one
+         * 3. id is unknown - this is an error
+         */
+        id = g_strdup (previous_id);
+
+        handled = FALSE;
+        g_signal_emit (client, signals[REGISTER_REQUEST], 0, &id, &handled);
+        if (! handled) {
+                g_debug ("GsmXSMPClient:  RegisterClient not handled!");
+                g_free (id);
+                free (previous_id);
+                g_assert_not_reached ();
+                return FALSE;
+        }
+
+        if (IS_STRING_EMPTY (id)) {
+                g_debug ("GsmXSMPClient:   rejected: invalid previous_id");
+                free (previous_id);
+                return FALSE;
+        }
+
+        g_object_set (client, "startup-id", id, NULL);
+
+        set_description (client);
+
+        g_debug ("GsmXSMPClient: Sending RegisterClientReply to '%s'", client->priv->description);
+
+        SmsRegisterClientReply (conn, id);
+
+        if (IS_STRING_EMPTY (previous_id)) {
+                /* Send the initial SaveYourself. */
+                g_debug ("GsmXSMPClient: Sending initial SaveYourself");
+                SmsSaveYourself (conn, SmSaveLocal, False, SmInteractStyleNone, False);
+                client->priv->current_save_yourself = SmSaveLocal;
+        }
+
+        gsm_client_set_status (GSM_CLIENT (client), GSM_CLIENT_REGISTERED);
+
+        g_free (id);
+        free (previous_id);
+
+        return TRUE;
+}
+
+
+static void
+save_yourself_request_callback (SmsConn   conn,
+                                SmPointer manager_data,
+                                int       save_type,
+                                Bool      shutdown,
+                                int       interact_style,
+                                Bool      fast,
+                                Bool      global)
+{
+        GsmXSMPClient *client = manager_data;
+
+        g_debug ("GsmXSMPClient: Client '%s' received SaveYourselfRequest(%s, %s, %s, %s, %s)",
+                 client->priv->description,
+                 save_type == SmSaveLocal ? "SmSaveLocal" :
+                 save_type == SmSaveGlobal ? "SmSaveGlobal" : "SmSaveBoth",
+                 shutdown ? "Shutdown" : "!Shutdown",
+                 interact_style == SmInteractStyleAny ? "SmInteractStyleAny" :
+                 interact_style == SmInteractStyleErrors ? "SmInteractStyleErrors" :
+                 "SmInteractStyleNone", fast ? "Fast" : "!Fast",
+                 global ? "Global" : "!Global");
+
+        /* Examining the g_debug above, you can see that there are a total
+         * of 72 different combinations of options that this could have been
+         * called with. However, most of them are stupid.
+         *
+         * If @shutdown and @global are both TRUE, that means the caller is
+         * requesting that a logout message be sent to all clients, so we do
+         * that. We use @fast to decide whether or not to show a
+         * confirmation dialog. (This isn't really what @fast is for, but
+         * the old mate-session and ksmserver both interpret it that way,
+         * so we do too.) We ignore @save_type because we pick the correct
+         * save_type ourselves later based on user prefs, dialog choices,
+         * etc, and we ignore @interact_style, because clients have not used
+         * it correctly consistently enough to make it worth honoring.
+         *
+         * If @shutdown is TRUE and @global is FALSE, the caller is
+         * confused, so we ignore the request.
+         *
+         * If @shutdown is FALSE and @save_type is SmSaveGlobal or
+         * SmSaveBoth, then the client wants us to ask some or all open
+         * applications to save open files to disk, but NOT quit. This is
+         * silly and so we ignore the request.
+         *
+         * If @shutdown is FALSE and @save_type is SmSaveLocal, then the
+         * client wants us to ask some or all open applications to update
+         * their current saved state, but not log out. At the moment, the
+         * code only supports this for the !global case (ie, a client
+         * requesting that it be allowed to update *its own* saved state,
+         * but not having everyone else update their saved state).
+         */
+
+        if (shutdown && global) {
+                g_debug ("GsmXSMPClient:   initiating shutdown");
+                g_signal_emit (client, signals[LOGOUT_REQUEST], 0, !fast);
+        } else if (!shutdown && !global) {
+                g_debug ("GsmXSMPClient:   initiating checkpoint");
+                do_save_yourself (client, SmSaveLocal, TRUE);
+        } else {
+                g_debug ("GsmXSMPClient:   ignoring");
+        }
+}
+
+static void
+save_yourself_phase2_request_callback (SmsConn   conn,
+                                       SmPointer manager_data)
+{
+        GsmXSMPClient *client = manager_data;
+
+        g_debug ("GsmXSMPClient: Client '%s' received SaveYourselfPhase2Request",
+                 client->priv->description);
+
+        client->priv->current_save_yourself = -1;
+
+        /* this is a valid response to SaveYourself and therefore
+           may be a response to a QES or ES */
+        gsm_client_end_session_response (GSM_CLIENT (client),
+                                         TRUE, TRUE, FALSE,
+                                         NULL);
+}
+
+static void
+interact_request_callback (SmsConn   conn,
+                           SmPointer manager_data,
+                           int       dialog_type)
+{
+        GsmXSMPClient *client = manager_data;
+#if 0
+        gboolean       res;
+        GError        *error;
+#endif
+
+        g_debug ("GsmXSMPClient: Client '%s' received InteractRequest(%s)",
+                 client->priv->description,
+                 dialog_type == SmDialogNormal ? "Dialog" : "Errors");
+
+        gsm_client_end_session_response (GSM_CLIENT (client),
+                                         FALSE, FALSE, FALSE,
+                                         _("This program is blocking logout."));
+
+#if 0
+        /* Can't just call back with Interact because session client
+           grabs the keyboard!  So, we try to get it to release
+           grabs by telling it we've cancelled the shutdown.
+           This grabbing is clearly bullshit and is not supported by
+           the client spec or protocol spec.
+        */
+        res = xsmp_cancel_end_session (GSM_CLIENT (client), &error);
+        if (! res) {
+                g_warning ("Unable to cancel end session: %s", error->message);
+                g_error_free (error);
+        }
+#endif
+        xsmp_interact (GSM_CLIENT (client));
+}
+
+static void
+interact_done_callback (SmsConn   conn,
+                        SmPointer manager_data,
+                        Bool      cancel_shutdown)
+{
+        GsmXSMPClient *client = manager_data;
+
+        g_debug ("GsmXSMPClient: Client '%s' received InteractDone(cancel_shutdown = %s)",
+                 client->priv->description,
+                 cancel_shutdown ? "True" : "False");
+
+        gsm_client_end_session_response (GSM_CLIENT (client),
+                                         TRUE, FALSE, cancel_shutdown,
+                                         NULL);
+}
+
+static void
+save_yourself_done_callback (SmsConn   conn,
+                             SmPointer manager_data,
+                             Bool      success)
+{
+        GsmXSMPClient *client = manager_data;
+
+        g_debug ("GsmXSMPClient: Client '%s' received SaveYourselfDone(success = %s)",
+                 client->priv->description,
+                 success ? "True" : "False");
+
+	if (client->priv->current_save_yourself != -1) {
+		SmsSaveComplete (client->priv->conn);
+		client->priv->current_save_yourself = -1;
+	}
+
+        /* If success is false then the application couldn't save data. Nothing
+         * the session manager can do about, though. FIXME: we could display a
+         * dialog about this, I guess. */
+        gsm_client_end_session_response (GSM_CLIENT (client),
+                                         TRUE, FALSE, FALSE,
+                                         NULL);
+
+        if (client->priv->next_save_yourself) {
+                int      save_type = client->priv->next_save_yourself;
+                gboolean allow_interact = client->priv->next_save_yourself_allow_interact;
+
+                client->priv->next_save_yourself = -1;
+                client->priv->next_save_yourself_allow_interact = -1;
+                do_save_yourself (client, save_type, allow_interact);
+        }
+}
+
+static void
+close_connection_callback (SmsConn     conn,
+                           SmPointer   manager_data,
+                           int         count,
+                           char      **reason_msgs)
+{
+        GsmXSMPClient *client = manager_data;
+        int            i;
+
+        g_debug ("GsmXSMPClient: Client '%s' received CloseConnection", client->priv->description);
+        for (i = 0; i < count; i++) {
+                g_debug ("GsmXSMPClient:  close reason: '%s'", reason_msgs[i]);
+        }
+        SmFreeReasons (count, reason_msgs);
+
+        gsm_client_set_status (GSM_CLIENT (client), GSM_CLIENT_FINISHED);
+        gsm_client_disconnected (GSM_CLIENT (client));
+}
+
+void
+gsm_xsmp_client_connect (GsmXSMPClient *client,
+                         SmsConn        conn,
+                         unsigned long *mask_ret,
+                         SmsCallbacks  *callbacks_ret)
+{
+        client->priv->conn = conn;
+
+        g_debug ("GsmXSMPClient: Initializing client %s", client->priv->description);
+
+        *mask_ret = 0;
+
+        *mask_ret |= SmsRegisterClientProcMask;
+        callbacks_ret->register_client.callback = register_client_callback;
+        callbacks_ret->register_client.manager_data  = client;
+
+        *mask_ret |= SmsInteractRequestProcMask;
+        callbacks_ret->interact_request.callback = interact_request_callback;
+        callbacks_ret->interact_request.manager_data = client;
+
+        *mask_ret |= SmsInteractDoneProcMask;
+        callbacks_ret->interact_done.callback = interact_done_callback;
+        callbacks_ret->interact_done.manager_data = client;
+
+        *mask_ret |= SmsSaveYourselfRequestProcMask;
+        callbacks_ret->save_yourself_request.callback = save_yourself_request_callback;
+        callbacks_ret->save_yourself_request.manager_data = client;
+
+        *mask_ret |= SmsSaveYourselfP2RequestProcMask;
+        callbacks_ret->save_yourself_phase2_request.callback = save_yourself_phase2_request_callback;
+        callbacks_ret->save_yourself_phase2_request.manager_data = client;
+
+        *mask_ret |= SmsSaveYourselfDoneProcMask;
+        callbacks_ret->save_yourself_done.callback = save_yourself_done_callback;
+        callbacks_ret->save_yourself_done.manager_data = client;
+
+        *mask_ret |= SmsCloseConnectionProcMask;
+        callbacks_ret->close_connection.callback = close_connection_callback;
+        callbacks_ret->close_connection.manager_data  = client;
+
+        *mask_ret |= SmsSetPropertiesProcMask;
+        callbacks_ret->set_properties.callback = set_properties_callback;
+        callbacks_ret->set_properties.manager_data = client;
+
+        *mask_ret |= SmsDeletePropertiesProcMask;
+        callbacks_ret->delete_properties.callback = delete_properties_callback;
+        callbacks_ret->delete_properties.manager_data = client;
+
+        *mask_ret |= SmsGetPropertiesProcMask;
+        callbacks_ret->get_properties.callback = get_properties_callback;
+        callbacks_ret->get_properties.manager_data = client;
+}
+
+void
+gsm_xsmp_client_save_state (GsmXSMPClient *client)
+{
+        g_return_if_fail (GSM_IS_XSMP_CLIENT (client));
+}