Adding upstream version 3.38.2.1.upstream/3.38.2.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1088 insertions, 0 deletions

diff --git a/daemon/gdm-server.c b/daemon/gdm-server.c
new file mode 100644
index 0000000..1ba00d4
--- /dev/null
+++ b/daemon/gdm-server.c
@@ -0,0 +1,1088 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2007 William Jon McCann <mccann@jhu.edu>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <errno.h>
+#include <ctype.h>
+#include <pwd.h>
+#include <grp.h>
+#include <signal.h>
+#include <sys/ioctl.h>
+#include <sys/resource.h>
+
+#ifdef HAVE_SYS_PRCTL_H
+#include <sys/prctl.h>
+#endif
+
+#ifdef WITH_PLYMOUTH
+#include <linux/vt.h>
+#endif
+
+#include <systemd/sd-daemon.h>
+
+#ifdef ENABLE_SYSTEMD_JOURNAL
+#include <systemd/sd-journal.h>
+#endif
+
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+#include <gio/gio.h>
+
+#include <X11/Xlib.h> /* for Display */
+
+#include "gdm-common.h"
+#include "gdm-settings-direct.h"
+#include "gdm-settings-keys.h"
+
+#include "gdm-server.h"
+
+extern char **environ;
+
+#define MAX_LOGS 5
+
+struct _GdmServer
+{
+        GObject  parent;
+
+        char    *command;
+        GPid     pid;
+
+        gboolean disable_tcp;
+        int      priority;
+        char    *user_name;
+        char    *session_args;
+
+        char    *log_dir;
+        char    *display_name;
+        char    *display_device;
+        char    *display_seat_id;
+        char    *auth_file;
+
+        guint    child_watch_id;
+
+        gboolean is_initial;
+};
+
+enum {
+        PROP_0,
+        PROP_DISPLAY_NAME,
+        PROP_DISPLAY_SEAT_ID,
+        PROP_DISPLAY_DEVICE,
+        PROP_AUTH_FILE,
+        PROP_USER_NAME,
+        PROP_DISABLE_TCP,
+        PROP_IS_INITIAL,
+};
+
+enum {
+        READY,
+        EXITED,
+        DIED,
+        LAST_SIGNAL
+};
+
+static guint signals [LAST_SIGNAL] = { 0, };
+
+static void     gdm_server_class_init   (GdmServerClass *klass);
+static void     gdm_server_init         (GdmServer      *server);
+static void     gdm_server_finalize     (GObject        *object);
+
+G_DEFINE_TYPE (GdmServer, gdm_server, G_TYPE_OBJECT)
+
+char *
+gdm_server_get_display_device (GdmServer *server)
+{
+        /* systemd finds the display device out on its own based on the display */
+        return NULL;
+}
+
+static void
+gdm_server_ready (GdmServer *server)
+{
+        g_debug ("GdmServer: Got USR1 from X server - emitting READY");
+
+        gdm_run_script (GDMCONFDIR "/Init", GDM_USERNAME,
+                        server->display_name,
+                        NULL, /* hostname */
+                        server->auth_file);
+
+        g_signal_emit (server, signals[READY], 0);
+}
+
+static GSList *active_servers;
+static gboolean sigusr1_thread_running;
+static GCond sigusr1_thread_cond;
+static GMutex sigusr1_thread_mutex;
+
+static gboolean
+got_sigusr1 (gpointer user_data)
+{
+        GPid pid = GPOINTER_TO_UINT (user_data);
+        GSList *l;
+
+        g_debug ("GdmServer: got SIGUSR1 from PID %d", pid);
+
+        for (l = active_servers; l; l = l->next) {
+                GdmServer *server = l->data;
+
+                if (server->pid == pid)
+                        gdm_server_ready (server);
+        }
+
+        return G_SOURCE_REMOVE;
+}
+
+static gpointer
+sigusr1_thread_main (gpointer user_data)
+{
+        sigset_t sigusr1_mask;
+
+        /* Handle only SIGUSR1 */
+        sigemptyset (&sigusr1_mask);
+        sigaddset (&sigusr1_mask, SIGUSR1);
+        sigprocmask (SIG_SETMASK, &sigusr1_mask, NULL);
+
+        g_mutex_lock (&sigusr1_thread_mutex);
+        sigusr1_thread_running = TRUE;
+        g_cond_signal (&sigusr1_thread_cond);
+        g_mutex_unlock (&sigusr1_thread_mutex);
+
+        /* Spin waiting for a SIGUSR1 */
+        while (TRUE) {
+                siginfo_t info;
+
+                if (sigwaitinfo (&sigusr1_mask, &info) == -1)
+                        continue;
+
+                g_idle_add (got_sigusr1, GUINT_TO_POINTER (info.si_pid));
+        }
+
+        return NULL;
+}
+
+static void
+gdm_server_launch_sigusr1_thread_if_needed (void)
+{
+        static GThread *sigusr1_thread;
+
+        if (sigusr1_thread == NULL) {
+                sigusr1_thread = g_thread_new ("gdm SIGUSR1 catcher", sigusr1_thread_main, NULL);
+
+                g_mutex_lock (&sigusr1_thread_mutex);
+                while (!sigusr1_thread_running)
+                        g_cond_wait (&sigusr1_thread_cond, &sigusr1_thread_mutex);
+                g_mutex_unlock (&sigusr1_thread_mutex);
+        }
+}
+
+static void
+gdm_server_init_command (GdmServer *server)
+{
+        gboolean debug = FALSE;
+        const char *debug_options;
+        const char *verbosity = "";
+
+        if (server->command != NULL) {
+                return;
+        }
+
+        gdm_settings_direct_get_boolean (GDM_KEY_DEBUG, &debug);
+        if (debug) {
+                debug_options = " -logverbose 7 -core ";
+        } else {
+                debug_options = "";
+        }
+
+#define X_SERVER_ARG_FORMAT " -background none -noreset -verbose %s%s"
+
+        /* This is a temporary hack to work around the fact that XOrg
+         * currently lacks support for multi-seat hotplugging for
+         * display devices. This bit should be removed as soon as XOrg
+         * gains native support for automatically enumerating usb
+         * based graphics adapters at start-up via udev. */
+
+        /* systemd ships an X server wrapper tool which simply invokes
+         * the usual X but ensures it only uses the display devices of
+         * the seat. */
+
+        /* We do not rely on this wrapper server if, a) the machine
+         * wasn't booted using systemd, or b) the wrapper tool is
+         * missing, or c) we are running for the main seat 'seat0'. */
+
+#ifdef ENABLE_SYSTEMD_JOURNAL
+        /* For systemd, we don't have a log file but instead log to stdout,
+           so set it to the xserver's built-in default verbosity */
+        if (debug)
+            verbosity = "7 -logfile /dev/null";
+        else
+            verbosity = "3 -logfile /dev/null";
+#endif
+
+        if (g_access (SYSTEMD_X_SERVER, X_OK) < 0) {
+                goto fallback;
+        }
+
+        if (server->display_seat_id == NULL ||
+            strcmp (server->display_seat_id, "seat0") == 0) {
+                goto fallback;
+        }
+
+        server->command = g_strdup_printf (SYSTEMD_X_SERVER X_SERVER_ARG_FORMAT, verbosity, debug_options);
+        return;
+
+fallback:
+        server->command = g_strdup_printf (X_SERVER X_SERVER_ARG_FORMAT, verbosity, debug_options);
+
+}
+
+static gboolean
+gdm_server_resolve_command_line (GdmServer  *server,
+                                 const char *vtarg,
+                                 int        *argcp,
+                                 char     ***argvp)
+{
+        int      argc;
+        char   **argv;
+        int      len;
+        int      i;
+        gboolean gotvtarg = FALSE;
+        gboolean query_in_arglist = FALSE;
+
+        gdm_server_init_command (server);
+
+        g_shell_parse_argv (server->command, &argc, &argv, NULL);
+
+        for (len = 0; argv != NULL && argv[len] != NULL; len++) {
+                char *arg = argv[len];
+
+                /* HACK! Not to add vt argument to servers that already force
+                 * allocation.  Mostly for backwards compat only */
+                if (strncmp (arg, "vt", 2) == 0 &&
+                    isdigit (arg[2]) &&
+                    (arg[3] == '\0' ||
+                     (isdigit (arg[3]) && arg[4] == '\0')))
+                        gotvtarg = TRUE;
+                if (strcmp (arg, "-query") == 0 ||
+                    strcmp (arg, "-indirect") == 0)
+                        query_in_arglist = TRUE;
+        }
+
+        argv = g_renew (char *, argv, len + 12);
+        /* shift args down one */
+        for (i = len - 1; i >= 1; i--) {
+                argv[i+1] = argv[i];
+        }
+
+        /* server number is the FIRST argument, before any others */
+        argv[1] = g_strdup (server->display_name);
+        len++;
+
+        if (server->auth_file != NULL) {
+                argv[len++] = g_strdup ("-auth");
+                argv[len++] = g_strdup (server->auth_file);
+        }
+
+        if (server->display_seat_id != NULL) {
+                argv[len++] = g_strdup ("-seat");
+                argv[len++] = g_strdup (server->display_seat_id);
+        }
+
+        /* If we were compiled with Xserver >= 1.17 we need to specify
+         * '-listen tcp' as the X server dosen't listen on tcp sockets
+         * by default anymore. In older versions we need to pass
+         * -nolisten tcp to disable listening on tcp sockets.
+         */
+#ifdef HAVE_XSERVER_THAT_DEFAULTS_TO_LOCAL_ONLY
+        if (!server->disable_tcp && ! query_in_arglist) {
+                argv[len++] = g_strdup ("-listen");
+                argv[len++] = g_strdup ("tcp");
+        }
+#else
+        if (server->disable_tcp && ! query_in_arglist) {
+                argv[len++] = g_strdup ("-nolisten");
+                argv[len++] = g_strdup ("tcp");
+        }
+
+#endif
+
+        if (vtarg != NULL && ! gotvtarg) {
+                argv[len++] = g_strdup (vtarg);
+        }
+
+        argv[len++] = NULL;
+
+        *argvp = argv;
+        *argcp = len;
+
+        return TRUE;
+}
+
+static void
+rotate_logs (const char *path,
+             guint       n_copies)
+{
+        int i;
+
+        for (i = n_copies - 1; i > 0; i--) {
+                char *name_n;
+                char *name_n1;
+
+                name_n = g_strdup_printf ("%s.%d", path, i);
+                if (i > 1) {
+                        name_n1 = g_strdup_printf ("%s.%d", path, i - 1);
+                } else {
+                        name_n1 = g_strdup (path);
+                }
+
+                VE_IGNORE_EINTR (g_unlink (name_n));
+                VE_IGNORE_EINTR (g_rename (name_n1, name_n));
+
+                g_free (name_n1);
+                g_free (name_n);
+        }
+
+        VE_IGNORE_EINTR (g_unlink (path));
+}
+
+static void
+change_user (GdmServer *server)
+{
+        struct passwd *pwent;
+
+        if (server->user_name == NULL) {
+                return;
+        }
+
+        gdm_get_pwent_for_name (server->user_name, &pwent);
+        if (pwent == NULL) {
+                g_warning (_("Server was to be spawned by user %s but that user doesn’t exist"),
+                           server->user_name);
+                _exit (EXIT_FAILURE);
+        }
+
+        g_debug ("GdmServer: Changing (uid:gid) for child process to (%d:%d)",
+                 pwent->pw_uid,
+                 pwent->pw_gid);
+
+        if (pwent->pw_uid != 0) {
+                if (setgid (pwent->pw_gid) < 0)  {
+                        g_warning (_("Couldn’t set groupid to %d"),
+                                   pwent->pw_gid);
+                        _exit (EXIT_FAILURE);
+                }
+
+                if (initgroups (pwent->pw_name, pwent->pw_gid) < 0) {
+                        g_warning (_("initgroups () failed for %s"),
+                                   pwent->pw_name);
+                        _exit (EXIT_FAILURE);
+                }
+
+                if (setuid (pwent->pw_uid) < 0)  {
+                        g_warning (_("Couldn’t set userid to %d"),
+                                   (int)pwent->pw_uid);
+                        _exit (EXIT_FAILURE);
+                }
+        } else {
+                gid_t groups[1] = { 0 };
+
+                if (setgid (0) < 0)  {
+                        g_warning (_("Couldn’t set groupid to %d"), 0);
+                        /* Don't error out, it's not fatal, if it fails we'll
+                         * just still be */
+                }
+
+                /* this will get rid of any suplementary groups etc... */
+                setgroups (1, groups);
+        }
+}
+
+static gboolean
+gdm_server_setup_journal_fds (GdmServer *server)
+{
+#ifdef ENABLE_SYSTEMD_JOURNAL
+    if (sd_booted () > 0) {
+        int out, err;
+        const char *prefix = "gdm-Xorg-";
+        char *identifier;
+        gsize size;
+
+        size = strlen (prefix) + strlen (server->display_name) + 1;
+        identifier = g_alloca (size);
+        strcpy (identifier, prefix);
+        strcat (identifier, server->display_name);
+        identifier[size - 1] = '\0';
+
+        out = sd_journal_stream_fd (identifier, LOG_INFO, FALSE);
+        if (out < 0)
+            return FALSE;
+
+        err = sd_journal_stream_fd (identifier, LOG_WARNING, FALSE);
+        if (err < 0) {
+            close (out);
+            return FALSE;
+        }
+
+        VE_IGNORE_EINTR (dup2 (out, 1));
+        VE_IGNORE_EINTR (dup2 (err, 2));
+        return TRUE;
+    }
+#endif
+    return FALSE;
+}
+
+static void
+gdm_server_setup_logfile (GdmServer *server)
+{
+        int              logfd;
+        char            *log_file;
+        char            *log_path;
+
+        log_file = g_strdup_printf ("%s.log", server->display_name);
+        log_path = g_build_filename (server->log_dir, log_file, NULL);
+        g_free (log_file);
+
+        /* Rotate the X server logs */
+        rotate_logs (log_path, MAX_LOGS);
+
+        g_debug ("GdmServer: Opening logfile for server %s", log_path);
+
+        VE_IGNORE_EINTR (g_unlink (log_path));
+        VE_IGNORE_EINTR (logfd = open (log_path, O_CREAT|O_APPEND|O_TRUNC|O_WRONLY|O_EXCL, 0644));
+
+        g_free (log_path);
+
+        if (logfd != -1) {
+                VE_IGNORE_EINTR (dup2 (logfd, 1));
+                VE_IGNORE_EINTR (dup2 (logfd, 2));
+                close (logfd);
+        } else {
+                g_warning (_("%s: Could not open log file for display %s!"),
+                           "gdm_server_spawn",
+                           server->display_name);
+        }
+}
+
+static void
+server_child_setup (GdmServer *server)
+{
+        struct sigaction ign_signal;
+        sigset_t         mask;
+
+        if (!gdm_server_setup_journal_fds(server))
+            gdm_server_setup_logfile(server);
+
+        /* The X server expects USR1/TTIN/TTOU to be SIG_IGN */
+        ign_signal.sa_handler = SIG_IGN;
+        ign_signal.sa_flags = SA_RESTART;
+        sigemptyset (&ign_signal.sa_mask);
+
+        if (sigaction (SIGUSR1, &ign_signal, NULL) < 0) {
+                g_warning (_("%s: Error setting %s to %s"),
+                           "gdm_server_spawn", "USR1", "SIG_IGN");
+                _exit (EXIT_FAILURE);
+        }
+
+        if (sigaction (SIGTTIN, &ign_signal, NULL) < 0) {
+                g_warning (_("%s: Error setting %s to %s"),
+                           "gdm_server_spawn", "TTIN", "SIG_IGN");
+                _exit (EXIT_FAILURE);
+        }
+
+        if (sigaction (SIGTTOU, &ign_signal, NULL) < 0) {
+                g_warning (_("%s: Error setting %s to %s"),
+                           "gdm_server_spawn", "TTOU", "SIG_IGN");
+                _exit (EXIT_FAILURE);
+        }
+
+        /* And HUP and TERM are at SIG_DFL from gdm_unset_signals,
+           we also have an empty mask and all that fun stuff */
+
+        /* unblock signals (especially HUP/TERM/USR1) so that we
+         * can control the X server */
+        sigemptyset (&mask);
+        sigprocmask (SIG_SETMASK, &mask, NULL);
+
+        /* Terminate the process when the parent dies */
+#ifdef HAVE_SYS_PRCTL_H
+        prctl (PR_SET_PDEATHSIG, SIGTERM);
+#endif
+
+        if (server->priority != 0) {
+                if (setpriority (PRIO_PROCESS, 0, server->priority)) {
+                        g_warning (_("%s: Server priority couldn’t be set to %d: %s"),
+                                   "gdm_server_spawn",
+                                   server->priority,
+                                   g_strerror (errno));
+                }
+        }
+
+        setpgid (0, 0);
+
+        change_user (server);
+}
+
+static void
+listify_hash (const char *key,
+              const char *value,
+              GPtrArray  *env)
+{
+        char *str;
+        str = g_strdup_printf ("%s=%s", key, value);
+        g_ptr_array_add (env, str);
+}
+
+static GPtrArray *
+get_server_environment (GdmServer *server)
+{
+        GPtrArray  *env;
+        char      **l;
+        GHashTable *hash;
+
+        env = g_ptr_array_new ();
+
+        /* create a hash table of current environment, then update keys has necessary */
+        hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
+        for (l = environ; *l != NULL; l++) {
+                char **str;
+                str = g_strsplit (*l, "=", 2);
+                g_hash_table_insert (hash, str[0], str[1]);
+                g_free (str);
+        }
+
+        /* modify environment here */
+        g_hash_table_insert (hash, g_strdup ("DISPLAY"), g_strdup (server->display_name));
+
+        if (server->user_name != NULL) {
+                struct passwd *pwent;
+
+                gdm_get_pwent_for_name (server->user_name, &pwent);
+
+                if (pwent->pw_dir != NULL
+                    && g_file_test (pwent->pw_dir, G_FILE_TEST_EXISTS)) {
+                        g_hash_table_insert (hash, g_strdup ("HOME"), g_strdup (pwent->pw_dir));
+                } else {
+                        /* Hack */
+                        g_hash_table_insert (hash, g_strdup ("HOME"), g_strdup ("/"));
+                }
+                g_hash_table_insert (hash, g_strdup ("SHELL"), g_strdup (pwent->pw_shell));
+                g_hash_table_remove (hash, "MAIL");
+        }
+
+        g_hash_table_foreach (hash, (GHFunc)listify_hash, env);
+        g_hash_table_destroy (hash);
+
+        g_ptr_array_add (env, NULL);
+
+        return env;
+}
+
+static void
+server_add_xserver_args (GdmServer *server,
+                         int       *argc,
+                         char    ***argv)
+{
+        int    count;
+        char **args;
+        int    len;
+        int    i;
+
+        len = *argc;
+        g_shell_parse_argv (server->session_args, &count, &args, NULL);
+        *argv = g_renew (char *, *argv, len + count + 1);
+
+        for (i=0; i < count;i++) {
+                *argv[len++] = g_strdup (args[i]);
+        }
+
+        *argc += count;
+
+        argv[len] = NULL;
+        g_strfreev (args);
+}
+
+static void
+server_child_watch (GPid       pid,
+                    int        status,
+                    GdmServer *server)
+{
+        g_debug ("GdmServer: child (pid:%d) done (%s:%d)",
+                 (int) pid,
+                 WIFEXITED (status) ? "status"
+                 : WIFSIGNALED (status) ? "signal"
+                 : "unknown",
+                 WIFEXITED (status) ? WEXITSTATUS (status)
+                 : WIFSIGNALED (status) ? WTERMSIG (status)
+                 : -1);
+
+        g_object_ref (server);
+
+        if (WIFEXITED (status)) {
+                int code = WEXITSTATUS (status);
+                g_signal_emit (server, signals [EXITED], 0, code);
+        } else if (WIFSIGNALED (status)) {
+                int num = WTERMSIG (status);
+                g_signal_emit (server, signals [DIED], 0, num);
+        }
+
+        g_spawn_close_pid (server->pid);
+        server->pid = -1;
+
+        g_object_unref (server);
+}
+
+static void
+prune_active_servers_list (GdmServer *server)
+{
+        active_servers = g_slist_remove (active_servers, server);
+}
+
+static gboolean
+gdm_server_spawn (GdmServer    *server,
+                  const char   *vtarg,
+                  GError      **error)
+{
+        int              argc;
+        gchar          **argv = NULL;
+        GPtrArray       *env = NULL;
+        gboolean         ret = FALSE;
+        char            *freeme;
+
+        /* Figure out the server command */
+        argv = NULL;
+        argc = 0;
+        gdm_server_resolve_command_line (server,
+                                         vtarg,
+                                         &argc,
+                                         &argv);
+
+        if (server->session_args) {
+                server_add_xserver_args (server, &argc, &argv);
+        }
+
+        if (argv[0] == NULL) {
+                g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
+                             _("%s: Empty server command for display %s"),
+                             "gdm_server_spawn",
+                             server->display_name);
+                goto out;
+        }
+
+        env = get_server_environment (server);
+
+        freeme = g_strjoinv (" ", argv);
+        g_debug ("GdmServer: Starting X server process: %s", freeme);
+        g_free (freeme);
+
+        active_servers = g_slist_append (active_servers, server);
+
+        g_object_weak_ref (G_OBJECT (server),
+                           (GWeakNotify)
+                           prune_active_servers_list,
+                           server);
+
+        gdm_server_launch_sigusr1_thread_if_needed ();
+
+        if (!g_spawn_async_with_pipes (NULL,
+                                       argv,
+                                       (char **)env->pdata,
+                                       G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
+                                       (GSpawnChildSetupFunc)server_child_setup,
+                                       server,
+                                       &server->pid,
+                                       NULL,
+                                       NULL,
+                                       NULL,
+                                       error))
+                goto out;
+
+        g_debug ("GdmServer: Started X server process %d - waiting for READY", (int)server->pid);
+
+        server->child_watch_id = g_child_watch_add (server->pid,
+                                                          (GChildWatchFunc)server_child_watch,
+                                                          server);
+
+        ret = TRUE;
+ out:
+        g_strfreev (argv);
+        if (env) {
+                g_ptr_array_foreach (env, (GFunc)g_free, NULL);
+                g_ptr_array_free (env, TRUE);
+        }
+        return ret;
+}
+
+/**
+ * gdm_server_start:
+ * @disp: Pointer to a GdmDisplay structure
+ *
+ * Starts a local X server. Handles retries and fatal errors properly.
+ */
+
+gboolean
+gdm_server_start (GdmServer *server)
+{
+        gboolean res = FALSE;
+        const char *vtarg = NULL;
+        GError *local_error = NULL;
+        GError **error = &local_error;
+
+        /* Hardcode the VT for the initial X server, but nothing else */
+        if (server->is_initial) {
+                vtarg = "vt" G_STRINGIFY (GDM_INITIAL_VT);
+        }
+
+        /* fork X server process */
+        if (!gdm_server_spawn (server, vtarg, error)) {
+                goto out;
+        }
+
+        res = TRUE;
+ out:
+        if (local_error) {
+                g_printerr ("%s\n", local_error->message);
+                g_clear_error (&local_error);
+        }
+        return res;
+}
+
+static void
+server_died (GdmServer *server)
+{
+        int exit_status;
+
+        g_debug ("GdmServer: Waiting on process %d", server->pid);
+        exit_status = gdm_wait_on_pid (server->pid);
+
+        if (WIFEXITED (exit_status) && (WEXITSTATUS (exit_status) != 0)) {
+                g_debug ("GdmServer: Wait on child process failed");
+        } else {
+                /* exited normally */
+        }
+
+        g_spawn_close_pid (server->pid);
+        server->pid = -1;
+
+        if (server->display_device != NULL) {
+                g_free (server->display_device);
+                server->display_device = NULL;
+                g_object_notify (G_OBJECT (server), "display-device");
+        }
+
+        g_debug ("GdmServer: Server died");
+}
+
+gboolean
+gdm_server_stop (GdmServer *server)
+{
+        int res;
+
+        if (server->pid <= 1) {
+                return TRUE;
+        }
+
+        /* remove watch source before we can wait on child */
+        if (server->child_watch_id > 0) {
+                g_source_remove (server->child_watch_id);
+                server->child_watch_id = 0;
+        }
+
+        g_debug ("GdmServer: Stopping server");
+
+        res = gdm_signal_pid (server->pid, SIGTERM);
+        if (res < 0) {
+        } else {
+                server_died (server);
+        }
+
+        return TRUE;
+}
+
+
+static void
+_gdm_server_set_display_name (GdmServer  *server,
+                              const char *name)
+{
+        g_free (server->display_name);
+        server->display_name = g_strdup (name);
+}
+
+static void
+_gdm_server_set_display_seat_id (GdmServer  *server,
+                                 const char *name)
+{
+        g_free (server->display_seat_id);
+        server->display_seat_id = g_strdup (name);
+}
+
+static void
+_gdm_server_set_auth_file (GdmServer  *server,
+                           const char *auth_file)
+{
+        g_free (server->auth_file);
+        server->auth_file = g_strdup (auth_file);
+}
+
+static void
+_gdm_server_set_user_name (GdmServer  *server,
+                           const char *name)
+{
+        g_free (server->user_name);
+        server->user_name = g_strdup (name);
+}
+
+static void
+_gdm_server_set_disable_tcp (GdmServer  *server,
+                             gboolean    disabled)
+{
+        server->disable_tcp = disabled;
+}
+
+static void
+_gdm_server_set_is_initial (GdmServer  *server,
+                            gboolean    initial)
+{
+        server->is_initial = initial;
+}
+
+static void
+gdm_server_set_property (GObject      *object,
+                         guint         prop_id,
+                         const GValue *value,
+                         GParamSpec   *pspec)
+{
+        GdmServer *self;
+
+        self = GDM_SERVER (object);
+
+        switch (prop_id) {
+        case PROP_DISPLAY_NAME:
+                _gdm_server_set_display_name (self, g_value_get_string (value));
+                break;
+        case PROP_DISPLAY_SEAT_ID:
+                _gdm_server_set_display_seat_id (self, g_value_get_string (value));
+                break;
+        case PROP_AUTH_FILE:
+                _gdm_server_set_auth_file (self, g_value_get_string (value));
+                break;
+        case PROP_USER_NAME:
+                _gdm_server_set_user_name (self, g_value_get_string (value));
+                break;
+        case PROP_DISABLE_TCP:
+                _gdm_server_set_disable_tcp (self, g_value_get_boolean (value));
+                break;
+        case PROP_IS_INITIAL:
+                _gdm_server_set_is_initial (self, g_value_get_boolean (value));
+                break;
+        default:
+                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+                break;
+        }
+}
+
+static void
+gdm_server_get_property (GObject    *object,
+                         guint       prop_id,
+                         GValue     *value,
+                         GParamSpec *pspec)
+{
+        GdmServer *self;
+
+        self = GDM_SERVER (object);
+
+        switch (prop_id) {
+        case PROP_DISPLAY_NAME:
+                g_value_set_string (value, self->display_name);
+                break;
+        case PROP_DISPLAY_SEAT_ID:
+                g_value_set_string (value, self->display_seat_id);
+                break;
+        case PROP_DISPLAY_DEVICE:
+                g_value_take_string (value,
+                                     gdm_server_get_display_device (self));
+                break;
+        case PROP_AUTH_FILE:
+                g_value_set_string (value, self->auth_file);
+                break;
+        case PROP_USER_NAME:
+                g_value_set_string (value, self->user_name);
+                break;
+        case PROP_DISABLE_TCP:
+                g_value_set_boolean (value, self->disable_tcp);
+                break;
+        case PROP_IS_INITIAL:
+                g_value_set_boolean (value, self->is_initial);
+                break;
+        default:
+                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+                break;
+        }
+}
+
+static void
+gdm_server_class_init (GdmServerClass *klass)
+{
+        GObjectClass    *object_class = G_OBJECT_CLASS (klass);
+
+        object_class->get_property = gdm_server_get_property;
+        object_class->set_property = gdm_server_set_property;
+        object_class->finalize = gdm_server_finalize;
+
+        signals [READY] =
+                g_signal_new ("ready",
+                              G_TYPE_FROM_CLASS (object_class),
+                              G_SIGNAL_RUN_LAST,
+                              0,
+                              NULL,
+                              NULL,
+                              g_cclosure_marshal_VOID__VOID,
+                              G_TYPE_NONE,
+                              0);
+        signals [EXITED] =
+                g_signal_new ("exited",
+                              G_OBJECT_CLASS_TYPE (object_class),
+                              G_SIGNAL_RUN_FIRST,
+                              0,
+                              NULL,
+                              NULL,
+                              g_cclosure_marshal_VOID__INT,
+                              G_TYPE_NONE,
+                              1,
+                              G_TYPE_INT);
+        signals [DIED] =
+                g_signal_new ("died",
+                              G_OBJECT_CLASS_TYPE (object_class),
+                              G_SIGNAL_RUN_FIRST,
+                              0,
+                              NULL,
+                              NULL,
+                              g_cclosure_marshal_VOID__INT,
+                              G_TYPE_NONE,
+                              1,
+                              G_TYPE_INT);
+
+        g_object_class_install_property (object_class,
+                                         PROP_DISPLAY_NAME,
+                                         g_param_spec_string ("display-name",
+                                                              "name",
+                                                              "name",
+                                                              NULL,
+                                                              G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
+        g_object_class_install_property (object_class,
+                                         PROP_DISPLAY_SEAT_ID,
+                                         g_param_spec_string ("display-seat-id",
+                                                              "Seat ID",
+                                                              "ID of the seat this display is running on",
+                                                              NULL,
+                                                              G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
+        g_object_class_install_property (object_class,
+                                         PROP_DISPLAY_DEVICE,
+                                         g_param_spec_string ("display-device",
+                                                              "Display Device",
+                                                              "Path to terminal display is running on",
+                                                              NULL,
+                                                              G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
+        g_object_class_install_property (object_class,
+                                         PROP_AUTH_FILE,
+                                         g_param_spec_string ("auth-file",
+                                                              "Authorization File",
+                                                              "Path to X authorization file",
+                                                              NULL,
+                                                              G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
+
+        g_object_class_install_property (object_class,
+                                         PROP_USER_NAME,
+                                         g_param_spec_string ("user-name",
+                                                              "user name",
+                                                              "user name",
+                                                              NULL,
+                                                              G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
+        g_object_class_install_property (object_class,
+                                         PROP_DISABLE_TCP,
+                                         g_param_spec_boolean ("disable-tcp",
+                                                               NULL,
+                                                               NULL,
+                                                               TRUE,
+                                                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
+        g_object_class_install_property (object_class,
+                                         PROP_IS_INITIAL,
+                                         g_param_spec_boolean ("is-initial",
+                                                               NULL,
+                                                               NULL,
+                                                               FALSE,
+                                                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
+}
+
+static void
+gdm_server_init (GdmServer *server)
+{
+        server->pid = -1;
+
+        server->log_dir = g_strdup (LOGDIR);
+}
+
+static void
+gdm_server_finalize (GObject *object)
+{
+        GdmServer *server;
+
+        g_return_if_fail (object != NULL);
+        g_return_if_fail (GDM_IS_SERVER (object));
+
+        server = GDM_SERVER (object);
+
+        gdm_server_stop (server);
+
+        g_free (server->command);
+        g_free (server->user_name);
+        g_free (server->session_args);
+        g_free (server->log_dir);
+        g_free (server->display_name);
+        g_free (server->display_seat_id);
+        g_free (server->display_device);
+        g_free (server->auth_file);
+
+        G_OBJECT_CLASS (gdm_server_parent_class)->finalize (object);
+}
+
+GdmServer *
+gdm_server_new (const char *display_name,
+                const char *seat_id,
+                const char *auth_file,
+                gboolean    initial)
+{
+        GObject *object;
+
+        object = g_object_new (GDM_TYPE_SERVER,
+                               "display-name", display_name,
+                               "display-seat-id", seat_id,
+                               "auth-file", auth_file,
+                               "is-initial", initial,
+                               NULL);
+
+        return GDM_SERVER (object);
+}