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

1 files changed, 1144 insertions, 0 deletions

diff --git a/mate-session/gsm-autostart-app.c b/mate-session/gsm-autostart-app.c
new file mode 100644
index 0000000..a696a96
--- /dev/null
+++ b/mate-session/gsm-autostart-app.c
@@ -0,0 +1,1144 @@
+/* -*- 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 <ctype.h>
+#include <string.h>
+#include <sys/wait.h>
+#include <errno.h>
+
+#include <glib.h>
+#include <gio/gio.h>
+
+#include <mateconf/mateconf-client.h>
+
+#include "gsm-autostart-app.h"
+#include "gsm-util.h"
+
+enum {
+        AUTOSTART_LAUNCH_SPAWN = 0,
+        AUTOSTART_LAUNCH_ACTIVATE
+};
+
+enum {
+        GSM_CONDITION_NONE          = 0,
+        GSM_CONDITION_IF_EXISTS     = 1,
+        GSM_CONDITION_UNLESS_EXISTS = 2,
+        GSM_CONDITION_MATE         = 3,
+        GSM_CONDITION_UNKNOWN       = 4
+};
+
+#define GSM_SESSION_CLIENT_DBUS_INTERFACE "org.mate.SessionClient"
+
+struct _GsmAutostartAppPrivate {
+        char                 *desktop_filename;
+        char                 *desktop_id;
+        char                 *startup_id;
+
+        EggDesktopFile       *desktop_file;
+
+        /* desktop file state */
+        char                 *condition_string;
+        gboolean              condition;
+        gboolean              autorestart;
+
+        GFileMonitor         *condition_monitor;
+        guint                 condition_notify_id;
+
+        int                   launch_type;
+        GPid                  pid;
+        guint                 child_watch_id;
+
+        DBusGProxy           *proxy;
+        DBusGProxyCall       *proxy_call;
+};
+
+enum {
+        CONDITION_CHANGED,
+        LAST_SIGNAL
+};
+
+enum {
+        PROP_0,
+        PROP_DESKTOP_FILENAME
+};
+
+static guint signals[LAST_SIGNAL] = { 0 };
+
+#define GSM_AUTOSTART_APP_GET_PRIVATE(object) (G_TYPE_INSTANCE_GET_PRIVATE ((object), GSM_TYPE_AUTOSTART_APP, GsmAutostartAppPrivate))
+
+G_DEFINE_TYPE (GsmAutostartApp, gsm_autostart_app, GSM_TYPE_APP)
+
+static void
+gsm_autostart_app_init (GsmAutostartApp *app)
+{
+        app->priv = GSM_AUTOSTART_APP_GET_PRIVATE (app);
+
+        app->priv->pid = -1;
+        app->priv->condition_monitor = NULL;
+        app->priv->condition = FALSE;
+}
+
+static gboolean
+is_disabled (GsmApp *app)
+{
+        GsmAutostartAppPrivate *priv;
+
+        priv = GSM_AUTOSTART_APP (app)->priv;
+
+        /* GSM_AUTOSTART_APP_ENABLED_KEY key, used by old mate-session */
+        if (egg_desktop_file_has_key (priv->desktop_file,
+                                      GSM_AUTOSTART_APP_ENABLED_KEY, NULL) &&
+            !egg_desktop_file_get_boolean (priv->desktop_file,
+                                           GSM_AUTOSTART_APP_ENABLED_KEY, NULL)) {
+                g_debug ("app %s is disabled by " GSM_AUTOSTART_APP_ENABLED_KEY,
+                         gsm_app_peek_id (app));
+                return TRUE;
+        }
+
+        /* Hidden key, used by autostart spec */
+        if (egg_desktop_file_get_boolean (priv->desktop_file,
+                                          EGG_DESKTOP_FILE_KEY_HIDDEN, NULL)) {
+                g_debug ("app %s is disabled by Hidden",
+                         gsm_app_peek_id (app));
+                return TRUE;
+        }
+
+        /* Check OnlyShowIn/NotShowIn/TryExec */
+        if (!egg_desktop_file_can_launch (priv->desktop_file, "MATE")) {
+                g_debug ("app %s not installed or not for MATE",
+                         gsm_app_peek_id (app));
+                return TRUE;
+        }
+
+        /* Do not check AutostartCondition - this method is only to determine
+         if the app is unconditionally disabled */
+
+        return FALSE;
+}
+
+static gboolean
+parse_condition_string (const char *condition_string,
+                        guint      *condition_kindp,
+                        char      **keyp)
+{
+        const char *space;
+        const char *key;
+        int         len;
+        guint       kind;
+
+        space = condition_string + strcspn (condition_string, " ");
+        len = space - condition_string;
+        key = space;
+        while (isspace ((unsigned char)*key)) {
+                key++;
+        }
+
+        if (!g_ascii_strncasecmp (condition_string, "if-exists", len) && key) {
+                kind = GSM_CONDITION_IF_EXISTS;
+        } else if (!g_ascii_strncasecmp (condition_string, "unless-exists", len) && key) {
+                kind = GSM_CONDITION_UNLESS_EXISTS;
+        } else if (!g_ascii_strncasecmp (condition_string, "MATE", len)) {
+                kind = GSM_CONDITION_MATE;
+        } else {
+                key = NULL;
+                kind = GSM_CONDITION_UNKNOWN;
+        }
+
+        if (keyp != NULL) {
+                *keyp = g_strdup (key);
+        }
+
+        if (condition_kindp != NULL) {
+                *condition_kindp = kind;
+        }
+
+        return (kind != GSM_CONDITION_UNKNOWN);
+}
+
+static void
+if_exists_condition_cb (GFileMonitor     *monitor,
+                        GFile            *file,
+                        GFile            *other_file,
+                        GFileMonitorEvent event,
+                        GsmApp           *app)
+{
+        GsmAutostartAppPrivate *priv;
+        gboolean                condition = FALSE;
+
+        priv = GSM_AUTOSTART_APP (app)->priv;
+
+        switch (event) {
+        case G_FILE_MONITOR_EVENT_CREATED:
+                condition = TRUE;
+                break;
+        case G_FILE_MONITOR_EVENT_DELETED:
+                condition = FALSE;
+                break;
+        default:
+                /* Ignore any other monitor event */
+                return;
+        }
+
+        /* Emit only if the condition actually changed */
+        if (condition != priv->condition) {
+                priv->condition = condition;
+                g_signal_emit (app, signals[CONDITION_CHANGED], 0, condition);
+        }
+}
+
+static void
+unless_exists_condition_cb (GFileMonitor     *monitor,
+                            GFile            *file,
+                            GFile            *other_file,
+                            GFileMonitorEvent event,
+                            GsmApp           *app)
+{
+        GsmAutostartAppPrivate *priv;
+        gboolean                condition = FALSE;
+
+        priv = GSM_AUTOSTART_APP (app)->priv;
+
+        switch (event) {
+        case G_FILE_MONITOR_EVENT_CREATED:
+                condition = FALSE;
+                break;
+        case G_FILE_MONITOR_EVENT_DELETED:
+                condition = TRUE;
+                break;
+        default:
+                /* Ignore any other monitor event */
+                return;
+        }
+
+        /* Emit only if the condition actually changed */
+        if (condition != priv->condition) {
+                priv->condition = condition;
+                g_signal_emit (app, signals[CONDITION_CHANGED], 0, condition);
+        }
+}
+
+static void
+mateconf_condition_cb (MateConfClient *client,
+                    guint        cnxn_id,
+                    MateConfEntry  *entry,
+                    gpointer     user_data)
+{
+        GsmApp                 *app;
+        GsmAutostartAppPrivate *priv;
+        gboolean                condition;
+
+        g_return_if_fail (GSM_IS_APP (user_data));
+
+        app = GSM_APP (user_data);
+
+        priv = GSM_AUTOSTART_APP (app)->priv;
+
+        condition = FALSE;
+        if (entry->value != NULL && entry->value->type == MATECONF_VALUE_BOOL) {
+                condition = mateconf_value_get_bool (entry->value);
+        }
+
+        g_debug ("GsmAutostartApp: app:%s condition changed condition:%d",
+                 gsm_app_peek_id (app),
+                 condition);
+
+        /* Emit only if the condition actually changed */
+        if (condition != priv->condition) {
+                priv->condition = condition;
+                g_signal_emit (app, signals[CONDITION_CHANGED], 0, condition);
+        }
+}
+
+static void
+setup_condition_monitor (GsmAutostartApp *app)
+{
+        guint    kind;
+        char    *key;
+        gboolean res;
+        gboolean disabled;
+
+        if (app->priv->condition_monitor != NULL) {
+                g_file_monitor_cancel (app->priv->condition_monitor);
+        }
+
+        if (app->priv->condition_notify_id > 0) {
+                MateConfClient *client;
+                client = mateconf_client_get_default ();
+                mateconf_client_notify_remove (client,
+                                            app->priv->condition_notify_id);
+                app->priv->condition_notify_id = 0;
+        }
+
+        if (app->priv->condition_string == NULL) {
+                return;
+        }
+
+        /* if it is disabled outright there is no point in monitoring */
+        if (is_disabled (GSM_APP (app))) {
+                return;
+        }
+
+        key = NULL;
+        res = parse_condition_string (app->priv->condition_string, &kind, &key);
+        if (! res) {
+                g_free (key);
+                return;
+        }
+
+        if (key == NULL) {
+                return;
+        }
+
+        if (kind == GSM_CONDITION_IF_EXISTS) {
+                char  *file_path;
+                GFile *file;
+
+                file_path = g_build_filename (g_get_user_config_dir (), key, NULL);
+
+                disabled = !g_file_test (file_path, G_FILE_TEST_EXISTS);
+
+                file = g_file_new_for_path (file_path);
+                app->priv->condition_monitor = g_file_monitor_file (file, 0, NULL, NULL);
+
+                g_signal_connect (app->priv->condition_monitor, "changed",
+                                  G_CALLBACK (if_exists_condition_cb),
+                                  app);
+
+                g_object_unref (file);
+                g_free (file_path);
+        } else if (kind == GSM_CONDITION_UNLESS_EXISTS) {
+                char  *file_path;
+                GFile *file;
+
+                file_path = g_build_filename (g_get_user_config_dir (), key, NULL);
+
+                disabled = g_file_test (file_path, G_FILE_TEST_EXISTS);
+
+                file = g_file_new_for_path (file_path);
+                app->priv->condition_monitor = g_file_monitor_file (file, 0, NULL, NULL);
+
+                g_signal_connect (app->priv->condition_monitor, "changed",
+                                  G_CALLBACK (unless_exists_condition_cb),
+                                  app);
+
+                g_object_unref (file);
+                g_free (file_path);
+        } else if (kind == GSM_CONDITION_MATE) {
+                MateConfClient *client;
+                char        *dir;
+
+                client = mateconf_client_get_default ();
+                g_assert (MATECONF_IS_CLIENT (client));
+
+                disabled = !mateconf_client_get_bool (client, key, NULL);
+
+                dir = g_path_get_dirname (key);
+
+                mateconf_client_add_dir (client,
+                                      dir,
+                                      MATECONF_CLIENT_PRELOAD_NONE, NULL);
+                g_free (dir);
+
+                app->priv->condition_notify_id = mateconf_client_notify_add (client,
+                                                                          key,
+                                                                          mateconf_condition_cb,
+                                                                          app, NULL, NULL);
+                g_object_unref (client);
+        } else {
+                disabled = TRUE;
+        }
+
+        g_free (key);
+
+        /* FIXME: cache the disabled value? */
+}
+
+static gboolean
+load_desktop_file (GsmAutostartApp *app)
+{
+        char    *dbus_name;
+        char    *startup_id;
+        char    *phase_str;
+        int      phase;
+        gboolean res;
+
+        if (app->priv->desktop_file == NULL) {
+                return FALSE;
+        }
+
+        phase_str = egg_desktop_file_get_string (app->priv->desktop_file,
+                                                 GSM_AUTOSTART_APP_PHASE_KEY,
+                                                 NULL);
+        if (phase_str != NULL) {
+                if (strcmp (phase_str, "Initialization") == 0) {
+                        phase = GSM_MANAGER_PHASE_INITIALIZATION;
+                } else if (strcmp (phase_str, "WindowManager") == 0) {
+                        phase = GSM_MANAGER_PHASE_WINDOW_MANAGER;
+                } else if (strcmp (phase_str, "Panel") == 0) {
+                        phase = GSM_MANAGER_PHASE_PANEL;
+                } else if (strcmp (phase_str, "Desktop") == 0) {
+                        phase = GSM_MANAGER_PHASE_DESKTOP;
+                } else {
+                        phase = GSM_MANAGER_PHASE_APPLICATION;
+                }
+
+                g_free (phase_str);
+        } else {
+                phase = GSM_MANAGER_PHASE_APPLICATION;
+        }
+
+        dbus_name = egg_desktop_file_get_string (app->priv->desktop_file,
+                                                 GSM_AUTOSTART_APP_DBUS_NAME_KEY,
+                                                 NULL);
+        if (dbus_name != NULL) {
+                app->priv->launch_type = AUTOSTART_LAUNCH_ACTIVATE;
+        } else {
+                app->priv->launch_type = AUTOSTART_LAUNCH_SPAWN;
+        }
+
+        /* this must only be done on first load */
+        switch (app->priv->launch_type) {
+        case AUTOSTART_LAUNCH_SPAWN:
+                startup_id =
+                        egg_desktop_file_get_string (app->priv->desktop_file,
+                                                     GSM_AUTOSTART_APP_STARTUP_ID_KEY,
+                                                     NULL);
+
+                if (startup_id == NULL) {
+                        startup_id = gsm_util_generate_startup_id ();
+                }
+                break;
+        case AUTOSTART_LAUNCH_ACTIVATE:
+                startup_id = g_strdup (dbus_name);
+                break;
+        default:
+                g_assert_not_reached ();
+        }
+
+        res = egg_desktop_file_has_key (app->priv->desktop_file,
+                                        GSM_AUTOSTART_APP_AUTORESTART_KEY,
+                                        NULL);
+        if (res) {
+                app->priv->autorestart = egg_desktop_file_get_boolean (app->priv->desktop_file,
+                                                                       GSM_AUTOSTART_APP_AUTORESTART_KEY,
+                                                                       NULL);
+        } else {
+                app->priv->autorestart = FALSE;
+        }
+
+        g_free (app->priv->condition_string);
+        app->priv->condition_string = egg_desktop_file_get_string (app->priv->desktop_file,
+                                                                   "AutostartCondition",
+                                                                   NULL);
+        setup_condition_monitor (app);
+
+        g_object_set (app,
+                      "phase", phase,
+                      "startup-id", startup_id,
+                      NULL);
+
+        g_free (startup_id);
+        g_free (dbus_name);
+
+        return TRUE;
+}
+
+static void
+gsm_autostart_app_set_desktop_filename (GsmAutostartApp *app,
+                                        const char      *desktop_filename)
+{
+        GError *error;
+
+        if (app->priv->desktop_file != NULL) {
+                egg_desktop_file_free (app->priv->desktop_file);
+                app->priv->desktop_file = NULL;
+                g_free (app->priv->desktop_id);
+        }
+
+        if (desktop_filename == NULL) {
+                return;
+        }
+
+        app->priv->desktop_id = g_path_get_basename (desktop_filename);
+
+        error = NULL;
+        app->priv->desktop_file = egg_desktop_file_new (desktop_filename, &error);
+        if (app->priv->desktop_file == NULL) {
+                g_warning ("Could not parse desktop file %s: %s",
+                           desktop_filename,
+                           error->message);
+                g_error_free (error);
+                return;
+        }
+}
+
+static void
+gsm_autostart_app_set_property (GObject      *object,
+                                guint         prop_id,
+                                const GValue *value,
+                                GParamSpec   *pspec)
+{
+        GsmAutostartApp *self;
+
+        self = GSM_AUTOSTART_APP (object);
+
+        switch (prop_id) {
+        case PROP_DESKTOP_FILENAME:
+                gsm_autostart_app_set_desktop_filename (self, g_value_get_string (value));
+                break;
+        default:
+                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+                break;
+        }
+}
+
+static void
+gsm_autostart_app_get_property (GObject    *object,
+                                guint       prop_id,
+                                GValue     *value,
+                                GParamSpec *pspec)
+{
+        GsmAutostartApp *self;
+
+        self = GSM_AUTOSTART_APP (object);
+
+        switch (prop_id) {
+        case PROP_DESKTOP_FILENAME:
+                if (self->priv->desktop_file != NULL) {
+                        g_value_set_string (value, egg_desktop_file_get_source (self->priv->desktop_file));
+                } else {
+                        g_value_set_string (value, NULL);
+                }
+                break;
+        default:
+                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+                break;
+        }
+}
+
+static void
+gsm_autostart_app_dispose (GObject *object)
+{
+        GsmAutostartAppPrivate *priv;
+
+        priv = GSM_AUTOSTART_APP (object)->priv;
+
+        if (priv->startup_id) {
+                g_free (priv->startup_id);
+                priv->startup_id = NULL;
+        }
+
+        if (priv->condition_string) {
+                g_free (priv->condition_string);
+                priv->condition_string = NULL;
+        }
+
+        if (priv->desktop_file) {
+                egg_desktop_file_free (priv->desktop_file);
+                priv->desktop_file = NULL;
+        }
+
+        if (priv->desktop_id) {
+                g_free (priv->desktop_id);
+                priv->desktop_id = NULL;
+        }
+
+        if (priv->child_watch_id > 0) {
+                g_source_remove (priv->child_watch_id);
+                priv->child_watch_id = 0;
+        }
+
+        if (priv->proxy_call != NULL) {
+                dbus_g_proxy_cancel_call (priv->proxy, priv->proxy_call);
+                priv->proxy_call = NULL;
+        }
+
+        if (priv->proxy != NULL) {
+                g_object_unref (priv->proxy);
+                priv->proxy = NULL;
+        }
+
+        if (priv->condition_monitor) {
+                g_file_monitor_cancel (priv->condition_monitor);
+        }
+
+        G_OBJECT_CLASS (gsm_autostart_app_parent_class)->dispose (object);
+}
+
+static gboolean
+is_running (GsmApp *app)
+{
+        GsmAutostartAppPrivate *priv;
+        gboolean                is;
+
+        priv = GSM_AUTOSTART_APP (app)->priv;
+
+        /* is running if pid is still valid or
+         * or a client is connected
+         */
+        /* FIXME: check client */
+        is = (priv->pid != -1);
+
+        return is;
+}
+
+static gboolean
+is_conditionally_disabled (GsmApp *app)
+{
+        GsmAutostartAppPrivate *priv;
+        gboolean                res;
+        gboolean                disabled;
+        char                   *key;
+        guint                   kind;
+
+        priv = GSM_AUTOSTART_APP (app)->priv;
+
+        /* Check AutostartCondition */
+        if (priv->condition_string == NULL) {
+                return FALSE;
+        }
+
+        key = NULL;
+        res = parse_condition_string (priv->condition_string, &kind, &key);
+        if (! res) {
+                g_free (key);
+                return TRUE;
+        }
+
+        if (key == NULL) {
+                return TRUE;
+        }
+
+        if (kind == GSM_CONDITION_IF_EXISTS) {
+                char *file_path;
+
+                file_path = g_build_filename (g_get_user_config_dir (), key, NULL);
+                disabled = !g_file_test (file_path, G_FILE_TEST_EXISTS);
+                g_free (file_path);
+        } else if (kind == GSM_CONDITION_UNLESS_EXISTS) {
+                char *file_path;
+
+                file_path = g_build_filename (g_get_user_config_dir (), key, NULL);
+                disabled = g_file_test (file_path, G_FILE_TEST_EXISTS);
+                g_free (file_path);
+        } else if (kind == GSM_CONDITION_MATE) {
+                MateConfClient *client;
+                client = mateconf_client_get_default ();
+                g_assert (MATECONF_IS_CLIENT (client));
+                disabled = !mateconf_client_get_bool (client, key, NULL);
+                g_object_unref (client);
+        } else {
+                disabled = TRUE;
+        }
+
+        /* Set initial condition */
+        priv->condition = !disabled;
+
+        g_free (key);
+
+        return disabled;
+}
+
+static void
+app_exited (GPid             pid,
+            int              status,
+            GsmAutostartApp *app)
+{
+        g_debug ("GsmAutostartApp: (pid:%d) done (%s:%d)",
+                 (int) pid,
+                 WIFEXITED (status) ? "status"
+                 : WIFSIGNALED (status) ? "signal"
+                 : "unknown",
+                 WIFEXITED (status) ? WEXITSTATUS (status)
+                 : WIFSIGNALED (status) ? WTERMSIG (status)
+                 : -1);
+
+        g_spawn_close_pid (app->priv->pid);
+        app->priv->pid = -1;
+        app->priv->child_watch_id = 0;
+
+        if (WIFEXITED (status)) {
+                gsm_app_exited (GSM_APP (app));
+        } else if (WIFSIGNALED (status)) {
+                gsm_app_died (GSM_APP (app));
+        }
+}
+
+static int
+_signal_pid (int pid,
+             int signal)
+{
+        int status = -1;
+
+        /* perhaps block sigchld */
+        g_debug ("GsmAutostartApp: sending signal %d to process %d", signal, pid);
+        errno = 0;
+        status = kill (pid, signal);
+
+        if (status < 0) {
+                if (errno == ESRCH) {
+                        g_warning ("Child process %d was already dead.",
+                                   (int)pid);
+                } else {
+                        g_warning ("Couldn't kill child process %d: %s",
+                                   pid,
+                                   g_strerror (errno));
+                }
+        }
+
+        /* perhaps unblock sigchld */
+
+        return status;
+}
+
+static gboolean
+autostart_app_stop_spawn (GsmAutostartApp *app,
+                          GError         **error)
+{
+        int res;
+
+        if (app->priv->pid < 1) {
+                g_set_error (error,
+                             GSM_APP_ERROR,
+                             GSM_APP_ERROR_STOP,
+                             "Not running");
+                return FALSE;
+        }
+
+        res = _signal_pid (app->priv->pid, SIGTERM);
+        if (res != 0) {
+                g_set_error (error,
+                             GSM_APP_ERROR,
+                             GSM_APP_ERROR_STOP,
+                             "Unable to stop: %s",
+                             g_strerror (errno));
+                return FALSE;
+        }
+
+        return TRUE;
+}
+
+static gboolean
+autostart_app_stop_activate (GsmAutostartApp *app,
+                             GError         **error)
+{
+        return TRUE;
+}
+
+static gboolean
+gsm_autostart_app_stop (GsmApp  *app,
+                        GError **error)
+{
+        GsmAutostartApp *aapp;
+        gboolean         ret;
+
+        aapp = GSM_AUTOSTART_APP (app);
+
+        g_return_val_if_fail (aapp->priv->desktop_file != NULL, FALSE);
+
+        switch (aapp->priv->launch_type) {
+        case AUTOSTART_LAUNCH_SPAWN:
+                ret = autostart_app_stop_spawn (aapp, error);
+                break;
+        case AUTOSTART_LAUNCH_ACTIVATE:
+                ret = autostart_app_stop_activate (aapp, error);
+                break;
+        default:
+                g_assert_not_reached ();
+                break;
+        }
+
+        return ret;
+}
+
+static gboolean
+autostart_app_start_spawn (GsmAutostartApp *app,
+                           GError         **error)
+{
+        char            *env[2] = { NULL, NULL };
+        gboolean         success;
+        GError          *local_error;
+        const char      *startup_id;
+        char            *command;
+
+        startup_id = gsm_app_peek_startup_id (GSM_APP (app));
+        g_assert (startup_id != NULL);
+
+        env[0] = g_strdup_printf ("DESKTOP_AUTOSTART_ID=%s", startup_id);
+
+        local_error = NULL;
+        command = egg_desktop_file_parse_exec (app->priv->desktop_file,
+                                               NULL,
+                                               &local_error);
+        if (command == NULL) {
+                g_warning ("Unable to parse command from  '%s': %s",
+                           egg_desktop_file_get_source (app->priv->desktop_file),
+                           local_error->message);
+                g_error_free (local_error);
+        }
+
+        g_debug ("GsmAutostartApp: starting %s: command=%s startup-id=%s", app->priv->desktop_id, command, startup_id);
+        g_free (command);
+
+        g_free (app->priv->startup_id);
+        local_error = NULL;
+        success = egg_desktop_file_launch (app->priv->desktop_file,
+                                           NULL,
+                                           &local_error,
+                                           EGG_DESKTOP_FILE_LAUNCH_PUTENV, env,
+                                           EGG_DESKTOP_FILE_LAUNCH_FLAGS, G_SPAWN_DO_NOT_REAP_CHILD,
+                                           EGG_DESKTOP_FILE_LAUNCH_RETURN_PID, &app->priv->pid,
+                                           EGG_DESKTOP_FILE_LAUNCH_RETURN_STARTUP_ID, &app->priv->startup_id,
+                                           NULL);
+        g_free (env[0]);
+
+        if (success) {
+                g_debug ("GsmAutostartApp: started pid:%d", app->priv->pid);
+                app->priv->child_watch_id = g_child_watch_add (app->priv->pid,
+                                                               (GChildWatchFunc)app_exited,
+                                                               app);
+        } else {
+                g_set_error (error,
+                             GSM_APP_ERROR,
+                             GSM_APP_ERROR_START,
+                             "Unable to start application: %s", local_error->message);
+                g_error_free (local_error);
+        }
+
+        return success;
+}
+
+static void
+start_notify (DBusGProxy      *proxy,
+              DBusGProxyCall  *call,
+              GsmAutostartApp *app)
+{
+        gboolean res;
+        GError  *error;
+
+        error = NULL;
+        res = dbus_g_proxy_end_call (proxy,
+                                     call,
+                                     &error,
+                                     G_TYPE_INVALID);
+        app->priv->proxy_call = NULL;
+
+        if (! res) {
+                g_warning ("GsmAutostartApp: Error starting application: %s", error->message);
+                g_error_free (error);
+        } else {
+                g_debug ("GsmAutostartApp: Started application %s", app->priv->desktop_id);
+        }
+}
+
+static gboolean
+autostart_app_start_activate (GsmAutostartApp  *app,
+                              GError          **error)
+{
+        const char      *name;
+        char            *path;
+        char            *arguments;
+        DBusGConnection *bus;
+        GError          *local_error;
+
+        local_error = NULL;
+        bus = dbus_g_bus_get (DBUS_BUS_SESSION, &local_error);
+        if (bus == NULL) {
+                if (local_error != NULL) {
+                        g_warning ("error getting session bus: %s", local_error->message);
+                }
+                g_propagate_error (error, local_error);
+                return FALSE;
+        }
+
+        name = gsm_app_peek_startup_id (GSM_APP (app));
+        g_assert (name != NULL);
+
+        path = egg_desktop_file_get_string (app->priv->desktop_file,
+                                            GSM_AUTOSTART_APP_DBUS_PATH_KEY,
+                                            NULL);
+        if (path == NULL) {
+                /* just pick one? */
+                path = g_strdup ("/");
+        }
+
+        arguments = egg_desktop_file_get_string (app->priv->desktop_file,
+                                                 GSM_AUTOSTART_APP_DBUS_ARGS_KEY,
+                                                 NULL);
+
+        app->priv->proxy = dbus_g_proxy_new_for_name (bus,
+                                                      name,
+                                                      path,
+                                                      GSM_SESSION_CLIENT_DBUS_INTERFACE);
+        if (app->priv->proxy == NULL) {
+                g_set_error (error,
+                             GSM_APP_ERROR,
+                             GSM_APP_ERROR_START,
+                             "Unable to start application: unable to create proxy for client");
+                return FALSE;
+        }
+
+        app->priv->proxy_call = dbus_g_proxy_begin_call (app->priv->proxy,
+                                                         "Start",
+                                                         (DBusGProxyCallNotify)start_notify,
+                                                         app,
+                                                         NULL,
+                                                         G_TYPE_STRING, arguments,
+                                                         G_TYPE_INVALID);
+        if (app->priv->proxy_call == NULL) {
+                g_object_unref (app->priv->proxy);
+                app->priv->proxy = NULL;
+                g_set_error (error,
+                             GSM_APP_ERROR,
+                             GSM_APP_ERROR_START,
+                             "Unable to start application: unable to call Start on client");
+                return FALSE;
+        }
+
+        return TRUE;
+}
+
+static gboolean
+gsm_autostart_app_start (GsmApp  *app,
+                         GError **error)
+{
+        GsmAutostartApp *aapp;
+        gboolean         ret;
+
+        aapp = GSM_AUTOSTART_APP (app);
+
+        g_return_val_if_fail (aapp->priv->desktop_file != NULL, FALSE);
+
+        switch (aapp->priv->launch_type) {
+        case AUTOSTART_LAUNCH_SPAWN:
+                ret = autostart_app_start_spawn (aapp, error);
+                break;
+        case AUTOSTART_LAUNCH_ACTIVATE:
+                ret = autostart_app_start_activate (aapp, error);
+                break;
+        default:
+                g_assert_not_reached ();
+                break;
+        }
+
+        return ret;
+}
+
+static gboolean
+gsm_autostart_app_restart (GsmApp  *app,
+                           GError **error)
+{
+        GError  *local_error;
+        gboolean res;
+
+        /* ignore stop errors - it is fine if it is already stopped */
+        local_error = NULL;
+        res = gsm_app_stop (app, &local_error);
+        if (! res) {
+                g_debug ("GsmAutostartApp: Couldn't stop app: %s", local_error->message);
+                g_error_free (local_error);
+        }
+
+        res = gsm_app_start (app, &local_error);
+        if (! res) {
+                g_propagate_error (error, local_error);
+                return FALSE;
+        }
+
+        return TRUE;
+}
+
+static gboolean
+gsm_autostart_app_provides (GsmApp     *app,
+                            const char *service)
+{
+        char           **provides;
+        gsize            len;
+        gsize            i;
+        GsmAutostartApp *aapp;
+
+        g_return_val_if_fail (GSM_IS_APP (app), FALSE);
+
+        aapp = GSM_AUTOSTART_APP (app);
+
+        if (aapp->priv->desktop_file == NULL) {
+                return FALSE;
+        }
+
+        provides = egg_desktop_file_get_string_list (aapp->priv->desktop_file,
+                                                     GSM_AUTOSTART_APP_PROVIDES_KEY,
+                                                     &len, NULL);
+        if (!provides) {
+                return FALSE;
+        }
+
+        for (i = 0; i < len; i++) {
+                if (!strcmp (provides[i], service)) {
+                        g_strfreev (provides);
+                        return TRUE;
+                }
+        }
+
+        g_strfreev (provides);
+        return FALSE;
+}
+
+static gboolean
+gsm_autostart_app_has_autostart_condition (GsmApp     *app,
+                                           const char *condition)
+{
+        GsmAutostartApp *aapp;
+
+        g_return_val_if_fail (GSM_IS_APP (app), FALSE);
+        g_return_val_if_fail (condition != NULL, FALSE);
+
+        aapp = GSM_AUTOSTART_APP (app);
+
+        if (aapp->priv->condition_string == NULL) {
+                return FALSE;
+        }
+
+        if (strcmp (aapp->priv->condition_string, condition) == 0) {
+                return TRUE;
+        }
+
+        return FALSE;
+}
+
+static gboolean
+gsm_autostart_app_get_autorestart (GsmApp *app)
+{
+        gboolean res;
+        gboolean autorestart;
+
+        if (GSM_AUTOSTART_APP (app)->priv->desktop_file == NULL) {
+                return FALSE;
+        }
+
+        autorestart = FALSE;
+
+        res = egg_desktop_file_has_key (GSM_AUTOSTART_APP (app)->priv->desktop_file,
+                                        GSM_AUTOSTART_APP_AUTORESTART_KEY,
+                                        NULL);
+        if (res) {
+                autorestart = egg_desktop_file_get_boolean (GSM_AUTOSTART_APP (app)->priv->desktop_file,
+                                                            GSM_AUTOSTART_APP_AUTORESTART_KEY,
+                                                            NULL);
+        }
+
+        return autorestart;
+}
+
+static const char *
+gsm_autostart_app_get_app_id (GsmApp *app)
+{
+        const char *location;
+        const char *slash;
+
+        if (GSM_AUTOSTART_APP (app)->priv->desktop_file == NULL) {
+                return NULL;
+        }
+
+        location = egg_desktop_file_get_source (GSM_AUTOSTART_APP (app)->priv->desktop_file);
+
+        slash = strrchr (location, '/');
+        if (slash != NULL) {
+                return slash + 1;
+        } else {
+                return location;
+        }
+}
+
+static GObject *
+gsm_autostart_app_constructor (GType                  type,
+                               guint                  n_construct_properties,
+                               GObjectConstructParam *construct_properties)
+{
+        GsmAutostartApp *app;
+
+        app = GSM_AUTOSTART_APP (G_OBJECT_CLASS (gsm_autostart_app_parent_class)->constructor (type,
+                                                                                               n_construct_properties,
+                                                                                               construct_properties));
+
+        if (! load_desktop_file (app)) {
+                g_object_unref (app);
+                app = NULL;
+        }
+
+        return G_OBJECT (app);
+}
+
+static void
+gsm_autostart_app_class_init (GsmAutostartAppClass *klass)
+{
+        GObjectClass *object_class = G_OBJECT_CLASS (klass);
+        GsmAppClass  *app_class = GSM_APP_CLASS (klass);
+
+        object_class->set_property = gsm_autostart_app_set_property;
+        object_class->get_property = gsm_autostart_app_get_property;
+        object_class->dispose = gsm_autostart_app_dispose;
+        object_class->constructor = gsm_autostart_app_constructor;
+
+        app_class->impl_is_disabled = is_disabled;
+        app_class->impl_is_conditionally_disabled = is_conditionally_disabled;
+        app_class->impl_is_running = is_running;
+        app_class->impl_start = gsm_autostart_app_start;
+        app_class->impl_restart = gsm_autostart_app_restart;
+        app_class->impl_stop = gsm_autostart_app_stop;
+        app_class->impl_provides = gsm_autostart_app_provides;
+        app_class->impl_has_autostart_condition = gsm_autostart_app_has_autostart_condition;
+        app_class->impl_get_app_id = gsm_autostart_app_get_app_id;
+        app_class->impl_get_autorestart = gsm_autostart_app_get_autorestart;
+
+        g_object_class_install_property (object_class,
+                                         PROP_DESKTOP_FILENAME,
+                                         g_param_spec_string ("desktop-filename",
+                                                              "Desktop filename",
+                                                              "Freedesktop .desktop file",
+                                                              NULL,
+                                                              G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+        signals[CONDITION_CHANGED] =
+                g_signal_new ("condition-changed",
+                              G_OBJECT_CLASS_TYPE (object_class),
+                              G_SIGNAL_RUN_LAST,
+                              G_STRUCT_OFFSET (GsmAutostartAppClass, condition_changed),
+                              NULL, NULL,
+                              g_cclosure_marshal_VOID__BOOLEAN,
+                              G_TYPE_NONE,
+                              1,
+                              G_TYPE_BOOLEAN);
+
+        g_type_class_add_private (object_class, sizeof (GsmAutostartAppPrivate));
+}
+
+GsmApp *
+gsm_autostart_app_new (const char *desktop_file)
+{
+        GsmAutostartApp *app;
+
+        app = g_object_new (GSM_TYPE_AUTOSTART_APP,
+                            "desktop-filename", desktop_file,
+                            NULL);
+
+        return GSM_APP (app);
+}