1 files changed, 543 insertions, 0 deletions
diff --git a/mate-session/main.c b/mate-session/main.c
new file mode 100644
index 0000000..2d7dd64
--- /dev/null
+++ b/mate-session/main.c
@@ -0,0 +1,543 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2006 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 <libintl.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include <glib/gi18n.h>
+#include <glib.h>
+#include <gtk/gtk.h>
+
+#include <dbus/dbus.h>
+#include <dbus/dbus-glib.h>
+#include <dbus/dbus-glib-bindings.h>
+#include <dbus/dbus-glib-lowlevel.h>
+
+#include "mdm-signal-handler.h"
+#include "mdm-log.h"
+
+#include "gsm-consolekit.h"
+#include "gsm-mateconf.h"
+#include "gsm-util.h"
+#include "gsm-manager.h"
+#include "gsm-xsmp-server.h"
+#include "gsm-store.h"
+
+#define GSM_MATECONF_DEFAULT_SESSION_KEY "/desktop/mate/session/default_session"
+#define GSM_MATECONF_REQUIRED_COMPONENTS_DIRECTORY "/desktop/mate/session/required_components"
+#define GSM_MATECONF_REQUIRED_COMPONENTS_LIST_KEY "/desktop/mate/session/required_components_list"
+
+#define GSM_DBUS_NAME "org.mate.SessionManager"
+
+#define IS_STRING_EMPTY(x) \
+	((x) == NULL || (x)[0] == '\0')
+
+static gboolean failsafe = FALSE;
+static gboolean show_version = FALSE;
+static gboolean debug = FALSE;
+
+static void on_bus_name_lost(DBusGProxy* bus_proxy, const char* name, gpointer data)
+{
+	g_warning("Lost name on bus: %s, exiting", name);
+	exit(1);
+}
+
+static gboolean acquire_name_on_proxy(DBusGProxy* bus_proxy, const char* name)
+{
+	GError* error;
+	guint result;
+	gboolean res;
+	gboolean ret;
+
+	ret = FALSE;
+
+	if (bus_proxy == NULL)
+	{
+		goto out;
+	}
+
+	error = NULL;
+	res = dbus_g_proxy_call(bus_proxy, "RequestName", &error, G_TYPE_STRING, name, G_TYPE_UINT, 0, G_TYPE_INVALID, G_TYPE_UINT, &result, G_TYPE_INVALID);
+
+	if (! res)
+	{
+		if (error != NULL)
+		{
+			g_warning("Failed to acquire %s: %s", name, error->message);
+			g_error_free(error);
+		}
+		else
+		{
+			g_warning ("Failed to acquire %s", name);
+		}
+
+		goto out;
+	}
+
+	if (result != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)
+	{
+		if (error != NULL)
+		{
+			g_warning("Failed to acquire %s: %s", name, error->message);
+			g_error_free(error);
+		}
+		else
+		{
+			g_warning("Failed to acquire %s", name);
+		}
+
+		goto out;
+	}
+
+	/* register for name lost */
+	dbus_g_proxy_add_signal(bus_proxy, "NameLost", G_TYPE_STRING, G_TYPE_INVALID);
+	dbus_g_proxy_connect_signal(bus_proxy, "NameLost", G_CALLBACK(on_bus_name_lost), NULL, NULL);
+
+	ret = TRUE;
+
+	out:
+
+	return ret;
+}
+
+static gboolean acquire_name(void)
+{
+	DBusGProxy* bus_proxy;
+	GError* error;
+	DBusGConnection* connection;
+
+	error = NULL;
+	connection = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
+
+	if (connection == NULL)
+	{
+		gsm_util_init_error(TRUE, "Could not connect to session bus: %s", error->message);
+		/* not reached */
+	}
+
+	bus_proxy = dbus_g_proxy_new_for_name(connection, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS);
+
+	if (!acquire_name_on_proxy(bus_proxy, GSM_DBUS_NAME))
+	{
+		gsm_util_init_error(TRUE, "%s", "Could not acquire name on session bus");
+		/* not reached */
+	}
+
+	g_object_unref(bus_proxy);
+
+	return TRUE;
+}
+
+/* This doesn't contain the required components, so we need to always
+ * call append_required_apps() after a call to append_default_apps(). */
+static void append_default_apps(GsmManager* manager, const char* default_session_key, char** autostart_dirs)
+{
+	GSList* default_apps;
+	GSList* a;
+	MateConfClient* client;
+
+	g_debug("main: *** Adding default apps");
+
+	g_assert(default_session_key != NULL);
+	g_assert(autostart_dirs != NULL);
+
+	client = mateconf_client_get_default();
+	default_apps = mateconf_client_get_list(client, default_session_key, MATECONF_VALUE_STRING, NULL);
+	g_object_unref(client);
+
+	for (a = default_apps; a; a = a->next)
+	{
+		char* app_path;
+
+		if (IS_STRING_EMPTY((char*) a->data))
+		{
+			continue;
+		}
+
+		app_path = gsm_util_find_desktop_file_for_app_name(a->data, autostart_dirs);
+
+		if (app_path != NULL)
+		{
+			gsm_manager_add_autostart_app(manager, app_path, NULL);
+			g_free(app_path);
+		}
+	}
+
+	g_slist_foreach(default_apps, (GFunc) g_free, NULL);
+	g_slist_free(default_apps);
+}
+
+static void append_required_apps(GsmManager* manager)
+{
+	GSList* required_components;
+	GSList* r;
+	MateConfClient* client;
+
+	g_debug("main: *** Adding required apps");
+
+	client = mateconf_client_get_default();
+	required_components = mateconf_client_get_list(client, GSM_MATECONF_REQUIRED_COMPONENTS_LIST_KEY, MATECONF_VALUE_STRING, NULL);
+
+	if (required_components == NULL)
+	{
+		g_warning("No required applications specified");
+	}
+
+	for (r = required_components; r != NULL; r = r->next)
+	{
+			char* path;
+			char* default_provider;
+			const char* component;
+
+			if (IS_STRING_EMPTY((char*) r->data))
+			{
+					continue;
+			}
+
+			component = r->data;
+
+			path = g_strdup_printf("%s/%s", GSM_MATECONF_REQUIRED_COMPONENTS_DIRECTORY, component);
+
+			default_provider = mateconf_client_get_string(client, path, NULL);
+
+			g_debug ("main: %s looking for component: '%s'", path, default_provider);
+
+			if (default_provider != NULL)
+			{
+				char* app_path;
+
+				app_path = gsm_util_find_desktop_file_for_app_name(default_provider, NULL);
+
+				if (app_path != NULL)
+				{
+					gsm_manager_add_autostart_app(manager, app_path, component);
+				}
+				else
+				{
+					g_warning("Unable to find provider '%s' of required component '%s'", default_provider, component);
+				}
+
+				g_free(app_path);
+			}
+
+			g_free(default_provider);
+			g_free(path);
+	}
+
+	g_debug("main: *** Done adding required apps");
+
+	g_slist_foreach(required_components, (GFunc) g_free, NULL);
+	g_slist_free(required_components);
+
+	g_object_unref(client);
+}
+
+static void maybe_load_saved_session_apps(GsmManager* manager)
+{
+	GsmConsolekit* consolekit;
+	char* session_type;
+
+	consolekit = gsm_get_consolekit();
+	session_type = gsm_consolekit_get_current_session_type(consolekit);
+
+	if (g_strcmp0 (session_type, GSM_CONSOLEKIT_SESSION_TYPE_LOGIN_WINDOW) != 0)
+	{
+		gsm_manager_add_autostart_apps_from_dir(manager, gsm_util_get_saved_session_dir());
+	}
+
+	g_object_unref(consolekit);
+	g_free(session_type);
+}
+
+static void load_standard_apps (GsmManager* manager, const char* default_session_key)
+{
+	char** autostart_dirs;
+	int i;
+
+	autostart_dirs = gsm_util_get_autostart_dirs();
+
+	if (!failsafe)
+	{
+		maybe_load_saved_session_apps(manager);
+
+		for (i = 0; autostart_dirs[i]; i++)
+		{
+			gsm_manager_add_autostart_apps_from_dir(manager, autostart_dirs[i]);
+		}
+	}
+
+	/* We do this at the end in case a saved session contains an
+	 * application that already provides one of the components. */
+	append_default_apps(manager, default_session_key, autostart_dirs);
+	append_required_apps(manager);
+
+	g_strfreev(autostart_dirs);
+}
+
+static void load_override_apps(GsmManager* manager, char** override_autostart_dirs)
+{
+	int i;
+
+	for (i = 0; override_autostart_dirs[i]; i++)
+	{
+		gsm_manager_add_autostart_apps_from_dir(manager, override_autostart_dirs[i]);
+	}
+}
+
+static gboolean signal_cb(int signo, gpointer data)
+{
+	int ret;
+	GsmManager* manager;
+
+	g_debug("Got callback for signal %d", signo);
+
+	ret = TRUE;
+
+	switch (signo)
+	{
+		case SIGFPE:
+		case SIGPIPE:
+			/* let the fatal signals interrupt us */
+			g_debug ("Caught signal %d, shutting down abnormally.", signo);
+			ret = FALSE;
+			break;
+		case SIGINT:
+		case SIGTERM:
+			manager = (GsmManager*) data;
+			gsm_manager_logout(manager, GSM_MANAGER_LOGOUT_MODE_FORCE, NULL);
+
+			/* let the fatal signals interrupt us */
+			g_debug("Caught signal %d, shutting down normally.", signo);
+			ret = TRUE;
+			break;
+		case SIGHUP:
+			g_debug("Got HUP signal");
+			ret = TRUE;
+			break;
+		case SIGUSR1:
+			g_debug("Got USR1 signal");
+			ret = TRUE;
+			mdm_log_toggle_debug();
+			break;
+		default:
+			g_debug("Caught unhandled signal %d", signo);
+			ret = TRUE;
+
+			break;
+	}
+
+	return ret;
+}
+
+static void shutdown_cb(gpointer data)
+{
+	GsmManager* manager = (GsmManager*) data;
+	g_debug("Calling shutdown callback function");
+
+	/*
+	 * When the signal handler gets a shutdown signal, it calls
+	 * this function to inform GsmManager to not restart
+	 * applications in the off chance a handler is already queued
+	 * to dispatch following the below call to gtk_main_quit.
+	 */
+	gsm_manager_set_phase(manager, GSM_MANAGER_PHASE_EXIT);
+
+	gtk_main_quit();
+}
+
+static gboolean require_dbus_session(int argc, char** argv, GError** error)
+{
+	char** new_argv;
+	int i;
+
+	if (g_getenv("DBUS_SESSION_BUS_ADDRESS"))
+	{
+		return TRUE;
+	}
+
+	/* Just a sanity check to prevent infinite recursion if
+	 * dbus-launch fails to set DBUS_SESSION_BUS_ADDRESS
+	 */
+	g_return_val_if_fail(!g_str_has_prefix(argv[0], "dbus-launch"), TRUE);
+
+	/* +2 for our new arguments, +1 for NULL */
+	new_argv = g_malloc(argc + 3 * sizeof (*argv));
+
+	new_argv[0] = "dbus-launch";
+	new_argv[1] = "--exit-with-session";
+
+	for (i = 0; i < argc; i++)
+	{
+		new_argv[i + 2] = argv[i];
+	}
+
+	new_argv[i + 2] = NULL;
+
+	if (!execvp("dbus-launch", new_argv))
+	{
+		g_set_error(error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED, "No session bus and could not exec dbus-launch: %s", g_strerror(errno));
+		return FALSE;
+	}
+
+	/* Should not be reached */
+	return TRUE;
+}
+
+int main(int argc, char** argv)
+{
+	struct sigaction sa;
+	GError* error;
+	char* display_str;
+	GsmManager* manager;
+	GsmStore* client_store;
+	GsmXsmpServer* xsmp_server;
+	MdmSignalHandler* signal_handler;
+	static char** override_autostart_dirs = NULL;
+	static char* default_session_key = NULL;
+
+	static GOptionEntry entries[] = {
+		{"autostart", 'a', 0, G_OPTION_ARG_STRING_ARRAY, &override_autostart_dirs, N_("Override standard autostart directories"), NULL},
+		{"default-session-key", 0, 0, G_OPTION_ARG_STRING, &default_session_key, N_("MateConf key used to look up default session"), NULL},
+		{"debug", 0, 0, G_OPTION_ARG_NONE, &debug, N_("Enable debugging code"), NULL},
+		{"failsafe", 'f', 0, G_OPTION_ARG_NONE, &failsafe, N_("Do not load user-specified applications"), NULL},
+		{"version", 0, 0, G_OPTION_ARG_NONE, &show_version, N_("Version of this application"), NULL},
+		{NULL, 0, 0, 0, NULL, NULL, NULL }
+	};
+
+	/* Make sure that we have a session bus */
+	if (!require_dbus_session(argc, argv, &error))
+	{
+		gsm_util_init_error(TRUE, "%s", error->message);
+	}
+
+	bindtextdomain(GETTEXT_PACKAGE, LOCALE_DIR);
+	bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
+	textdomain(GETTEXT_PACKAGE);
+
+	sa.sa_handler = SIG_IGN;
+	sa.sa_flags = 0;
+	sigemptyset(&sa.sa_mask);
+	sigaction(SIGPIPE, &sa, 0);
+
+	error = NULL;
+	gtk_init_with_args(&argc, &argv, (char*) _(" - the MATE session manager"), entries, GETTEXT_PACKAGE, &error);
+
+	if (error != NULL)
+	{
+		g_warning("%s", error->message);
+		exit(1);
+	}
+
+	if (show_version)
+	{
+		g_print("%s %s\n", argv [0], VERSION);
+		exit(1);
+	}
+
+	mdm_log_init();
+	mdm_log_set_debug(debug);
+
+	/* Set DISPLAY explicitly for all our children, in case --display
+	 * was specified on the command line.
+	 */
+	display_str = gdk_get_display();
+	gsm_util_setenv("DISPLAY", display_str);
+	g_free(display_str);
+
+	/* Some third-party programs rely on MATE_DESKTOP_SESSION_ID to
+	 * detect if MATE is running. We keep this for compatibility reasons.
+	 */
+	gsm_util_setenv("MATE_DESKTOP_SESSION_ID", "this-is-deprecated");
+
+	client_store = gsm_store_new();
+
+
+	/* Start up mateconfd if not already running. */
+	gsm_mateconf_init();
+
+	xsmp_server = gsm_xsmp_server_new(client_store);
+
+	/* Now make sure they succeeded. (They'll call
+	 * gsm_util_init_error() if they failed.)
+	 */
+	gsm_mateconf_check();
+	acquire_name();
+
+	manager = gsm_manager_new(client_store, failsafe);
+
+	signal_handler = mdm_signal_handler_new();
+	mdm_signal_handler_add_fatal(signal_handler);
+	mdm_signal_handler_add(signal_handler, SIGFPE, signal_cb, NULL);
+	mdm_signal_handler_add(signal_handler, SIGHUP, signal_cb, NULL);
+	mdm_signal_handler_add(signal_handler, SIGUSR1, signal_cb, NULL);
+	mdm_signal_handler_add(signal_handler, SIGTERM, signal_cb, manager);
+	mdm_signal_handler_add(signal_handler, SIGINT, signal_cb, manager);
+	mdm_signal_handler_set_fatal_func(signal_handler, shutdown_cb, manager);
+
+	if (override_autostart_dirs != NULL)
+	{
+		load_override_apps(manager, override_autostart_dirs);
+	}
+	else
+	{
+		if (!IS_STRING_EMPTY(default_session_key))
+		{
+			load_standard_apps(manager, default_session_key);
+		}
+		else
+		{
+			load_standard_apps(manager, GSM_MATECONF_DEFAULT_SESSION_KEY);
+		}
+	}
+
+	gsm_xsmp_server_start(xsmp_server);
+	gsm_manager_start(manager);
+
+	gtk_main();
+
+	if (xsmp_server != NULL)
+	{
+		g_object_unref(xsmp_server);
+	}
+
+	if (manager != NULL)
+	{
+		g_debug("Unreffing manager");
+		g_object_unref(manager);
+	}
+
+	if (client_store != NULL)
+	{
+		g_object_unref(client_store);
+	}
+
+	gsm_mateconf_shutdown();
+
+	mdm_log_shutdown();
+
+	return 0;
+}