~ci-train-bot/lightdm/lightdm-ubuntu-zesty-1679

/*

 * Copyright (C) 2010-2011 Robert Ancell.

 * Author: Robert Ancell <robert.ancell@canonical.com>

 *

 * 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 3 of the License, or (at your option) any later

 * version. See http://www.gnu.org/copyleft/gpl.html the full text of the

 * license.

 */

#include <stdlib.h>

#include <string.h>

#include <sys/wait.h>

#include "seat.h"

#include "configuration.h"

#include "guest-account.h"

#include "greeter-session.h"

#include "session-config.h"

enum {

    SESSION_ADDED,

    RUNNING_USER_SESSION,

    SESSION_REMOVED,

    STOPPED,

    LAST_SIGNAL

};

static guint signals[LAST_SIGNAL] = { 0 };

struct SeatPrivate

{

    /* XDG name for this seat */

    gchar *name;

    /* Configuration for this seat */

    GHashTable *properties;

    /* TRUE if this seat can run multiple sessions at once */

    gboolean supports_multi_session;

    /* TRUE if display server can be shared for sessions */

    gboolean share_display_server;

    /* The display servers on this seat */

    GList *display_servers;

    /* The sessions on this seat */

    GList *sessions;

    /* The last session set to active */

    Session *active_session;

    /* The session belonging to the active greeter user */

    Session *next_session;

    /* The session to set active when it starts */

    Session *session_to_activate;

    /* TRUE once we have started */

    gboolean started;

    /* TRUE if stopping this seat (waiting for displays to stop) */

    gboolean stopping;

    /* TRUE if stopped */

    gboolean stopped;

    /* The greeter to be started to replace the current one */

    GreeterSession *replacement_greeter;

};

static void seat_logger_iface_init (LoggerInterface *iface);

G_DEFINE_TYPE_WITH_CODE (Seat, seat, G_TYPE_OBJECT,

                         G_IMPLEMENT_INTERFACE (

                             LOGGER_TYPE, seat_logger_iface_init));

typedef struct

{

    gchar *name;

    GType type;

} SeatModule;

static GHashTable *seat_modules = NULL;

// FIXME: Make a get_display_server() that re-uses display servers if supported

static DisplayServer *create_display_server (Seat *seat, Session *session);

static gboolean start_display_server (Seat *seat, DisplayServer *display_server);

static GreeterSession *create_greeter_session (Seat *seat);

static void start_session (Seat *seat, Session *session);

static void

free_seat_module (gpointer data)

{

    SeatModule *module = data;

    g_free (module->name);

    g_free (module);

}

void

seat_register_module (const gchar *name, GType type)

{

    SeatModule *module;

    if (!seat_modules)

        seat_modules = g_hash_table_new_full (g_str_hash, g_str_equal, free_seat_module, NULL);

    g_debug ("Registered seat module %s", name);

    module = g_malloc0 (sizeof (SeatModule));

    module->name = g_strdup (name);

    module->type = type;

    g_hash_table_insert (seat_modules, g_strdup (name), module);

}

Seat *

seat_new (const gchar *module_name, const gchar *name)

{

    Seat *seat;

    SeatModule *m = NULL;

    g_return_val_if_fail (module_name != NULL, NULL);

    if (seat_modules)

        m = g_hash_table_lookup (seat_modules, module_name);

    if (!m)

        return NULL;

    seat = g_object_new (m->type, NULL);

    seat->priv->name = g_strdup (name);

    return seat;

}

void

seat_set_property (Seat *seat, const gchar *name, const gchar *value)

{

    g_return_if_fail (seat != NULL);

    g_hash_table_insert (seat->priv->properties, g_strdup (name), g_strdup (value));

}

const gchar *

seat_get_string_property (Seat *seat, const gchar *name)

{

    g_return_val_if_fail (seat != NULL, NULL);

    return g_hash_table_lookup (seat->priv->properties, name);

}

gchar **

seat_get_string_list_property (Seat *seat, const gchar *name)

{

    g_return_val_if_fail (seat != NULL, NULL);

    return g_strsplit (g_hash_table_lookup (seat->priv->properties, name), ";", 0);

}

gboolean

seat_get_boolean_property (Seat *seat, const gchar *name)

{

    const gchar *value;

    gint i, length = 0;

    value = seat_get_string_property (seat, name);

    if (!value)

        return FALSE;

    /* Count the number of non-whitespace characters */

    for (i = 0; value[i]; i++)

        if (!g_ascii_isspace (value[i]))

            length = i + 1;

    return strncmp (value, "true", MAX (length, 4)) == 0;

}

gint

seat_get_integer_property (Seat *seat, const gchar *name)

{

    const gchar *value;

    value = seat_get_string_property (seat, name);

    return value ? atoi (value) : 0;

}

const gchar *

seat_get_name (Seat *seat)

{

    return seat->priv->name;

}

void

seat_set_supports_multi_session (Seat *seat, gboolean supports_multi_session)

{

    g_return_if_fail (seat != NULL);

    seat->priv->supports_multi_session = supports_multi_session;

}

void

seat_set_share_display_server (Seat *seat, gboolean share_display_server)

{

    g_return_if_fail (seat != NULL);

    seat->priv->share_display_server = share_display_server;

}

gboolean

seat_start (Seat *seat)

{

    g_return_val_if_fail (seat != NULL, FALSE);

    l_debug (seat, "Starting");

    SEAT_GET_CLASS (seat)->setup (seat);

    seat->priv->started = SEAT_GET_CLASS (seat)->start (seat);

    return seat->priv->started;

}

GList *

seat_get_sessions (Seat *seat)

{

    g_return_val_if_fail (seat != NULL, NULL);

    return seat->priv->sessions;

}

static gboolean

set_greeter_idle (gpointer greeter)

{

    greeter_idle (GREETER (greeter));

    return FALSE;

}

void

seat_set_active_session (Seat *seat, Session *session)

{

    GList *link;

    g_return_if_fail (seat != NULL);

    SEAT_GET_CLASS (seat)->set_active_session (seat, session);

    /* Stop any greeters */

    for (link = seat->priv->sessions; link; link = link->next)

    {

        Session *s = link->data;

        if (s == session || session_get_is_stopping (s))

            continue;

        if (IS_GREETER_SESSION (s))

        {

            Greeter *greeter = greeter_session_get_greeter (GREETER_SESSION (s));

            if (greeter_get_resettable (greeter))

            {

                if (seat->priv->active_session == s)

                {

                    l_debug (seat, "Idling greeter");

                    /* Do this in an idle callback, because we might very well

                       be in the middle of responding to a START_SESSION

                       request by a greeter.  So they won't expect an IDLE

                       call during that.  Plus, this isn't time-sensitive. */

                    g_idle_add (set_greeter_idle, greeter);

                }

            }

            else

            {

                l_debug (seat, "Stopping greeter");

                session_stop (s);

            }

        }

    }

    /* Lock previous sessions */

    if (seat->priv->active_session && session != seat->priv->active_session && !IS_GREETER_SESSION (seat->priv->active_session))

        session_lock (seat->priv->active_session);

    session_activate (session);

    g_clear_object (&seat->priv->active_session);

    seat->priv->active_session = g_object_ref (session);

}

Session *

seat_get_active_session (Seat *seat)

{

    g_return_val_if_fail (seat != NULL, NULL);

    return SEAT_GET_CLASS (seat)->get_active_session (seat);

}

Session *

seat_get_next_session (Seat *seat)

{

    g_return_val_if_fail (seat != NULL, NULL);

    return seat->priv->next_session;

}

/**

 * Obtains the active session which lightdm expects to be active.

 *

 * This function is different from seat_get_active_session() in that the

 * later (in the case of local seats) dynamically finds the session that is

 * really active (based on the active VT), whereas this function returns the

 * session that lightdm activated last by itself, which may not be the actual

 * active session (i.e. VT changes).

 */

Session *

seat_get_expected_active_session (Seat *seat)

{

    g_return_val_if_fail (seat != NULL, NULL);

    return seat->priv->active_session;

}

/**

 * Sets the active session which lightdm expects to be active.

 *

 * This function is different from seat_set_active_session() in that the

 * later performs an actual session activation, whereas this function just

 * updates the active session after the session has been activated by some

 * means external to lightdm (i.e. VT changes).

 */

void

seat_set_externally_activated_session (Seat *seat, Session *session)

{

    g_return_if_fail (seat != NULL);

    g_clear_object (&seat->priv->active_session);

    seat->priv->active_session = g_object_ref (session);

}

Session *

seat_find_session_by_login1_id (Seat *seat, const gchar *login1_session_id)

{

    GList *session_link;

    for (session_link = seat->priv->sessions; session_link; session_link = session_link->next)

    {

        Session *session = session_link->data;

        if (g_strcmp0 (login1_session_id, session_get_login1_session_id (session)) == 0)

            return session;

    }

    return NULL;

}

gboolean

seat_get_can_switch (Seat *seat)

{

    g_return_val_if_fail (seat != NULL, FALSE);

    return seat_get_boolean_property (seat, "allow-user-switching") && seat->priv->supports_multi_session;

}

gboolean

seat_get_allow_guest (Seat *seat)

{

    g_return_val_if_fail (seat != NULL, FALSE);

    return seat_get_boolean_property (seat, "allow-guest") && guest_account_is_installed ();

}

static gboolean

run_script (Seat *seat, DisplayServer *display_server, const gchar *script_name, User *user)

{

    Process *script;

    gboolean result = FALSE;

    script = process_new (NULL, NULL);

    process_set_command (script, script_name);

    /* Set POSIX variables */

    process_set_clear_environment (script, TRUE);

    process_set_env (script, "SHELL", "/bin/sh");

    /* Variables required for regression tests */

    if (g_getenv ("LIGHTDM_TEST_ROOT"))

    {

        process_set_env (script, "LIGHTDM_TEST_ROOT", g_getenv ("LIGHTDM_TEST_ROOT"));

        process_set_env (script, "LD_PRELOAD", g_getenv ("LD_PRELOAD"));

        process_set_env (script, "LD_LIBRARY_PATH", g_getenv ("LD_LIBRARY_PATH"));

        process_set_env (script, "PATH", g_getenv ("PATH"));

    }

    else

        process_set_env (script, "PATH", "/usr/local/bin:/usr/bin:/bin");

    if (user)

    {

        process_set_env (script, "USER", user_get_name (user));

        process_set_env (script, "LOGNAME", user_get_name (user));

        process_set_env (script, "HOME", user_get_home_directory (user));

    }

    else

        process_set_env (script, "HOME", "/");

    SEAT_GET_CLASS (seat)->run_script (seat, display_server, script);

    if (process_start (script, TRUE))

    {

        int exit_status;

        exit_status = process_get_exit_status (script);

        if (WIFEXITED (exit_status))

        {

            l_debug (seat, "Exit status of %s: %d", script_name, WEXITSTATUS (exit_status));

            result = WEXITSTATUS (exit_status) == EXIT_SUCCESS;

        }

    }

    g_object_unref (script);

    return result;

}

static void

seat_real_run_script (Seat *seat, DisplayServer *display_server, Process *process)

{

}

static void

emit_upstart_signal (const gchar *signal)

{

    g_return_if_fail (signal != NULL);

    g_return_if_fail (signal[0] != 0);

    GSubprocess *p;

    if (getuid () != 0)

        return;

    /* OK if it fails, probably not installed or not running upstart */

    p = g_subprocess_new (G_SUBPROCESS_FLAGS_STDERR_SILENCE, NULL, "initctl", "-q", "emit", signal, "DISPLAY_MANAGER=lightdm", NULL);

    g_object_unref (p);

}

static void

check_stopped (Seat *seat)

{

    if (seat->priv->stopping &&

        !seat->priv->stopped &&

        g_list_length (seat->priv->display_servers) == 0 &&

        g_list_length (seat->priv->sessions) == 0)

    {

        seat->priv->stopped = TRUE;

        l_debug (seat, "Stopped");

        g_signal_emit (seat, signals[STOPPED], 0);

    }

}

static void

display_server_stopped_cb (DisplayServer *display_server, Seat *seat)

{

    const gchar *script;

    GList *list, *link;

    Session *active_session;

    l_debug (seat, "Display server stopped");

    /* Run a script right after stopping the display server */

    script = seat_get_string_property (seat, "display-stopped-script");

    if (script)

        run_script (seat, NULL, script, NULL);

    g_signal_handlers_disconnect_matched (display_server, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, seat);

    seat->priv->display_servers = g_list_remove (seat->priv->display_servers, display_server);

    if (seat->priv->stopping || !seat->priv->started)

    {

        check_stopped (seat);

        g_object_unref (display_server);

        return;

    }

    /* Stop all sessions on this display server */

    list = g_list_copy (seat->priv->sessions);

    for (link = list; link; link = link->next)

        g_object_ref (link->data);

    for (link = list; link; link = link->next)

    {

        Session *session = link->data;

        if (session_get_display_server (session) != display_server || session_get_is_stopping (session))

            continue;

        /* Stop seat if this is the only display server and it failed to start a greeter */

        if (IS_GREETER_SESSION (session) &&

            !session_get_is_started (session) &&

            g_list_length (seat->priv->display_servers) == 0)

        {

            l_debug (seat, "Stopping; greeter display server failed to start");

            seat_stop (seat);

        }

        l_debug (seat, "Stopping session");

        session_stop (session);

    }

    g_list_free_full (list, g_object_unref);

    if (!seat->priv->stopping)

    {

        /* If we were the active session, switch to a greeter */

        active_session = seat_get_active_session (seat);

        if (!active_session || session_get_display_server (active_session) == display_server)

        {

            l_debug (seat, "Active display server stopped, starting greeter");

            if (!seat_switch_to_greeter (seat))

            {

                l_debug (seat, "Stopping; failed to start a greeter");

                seat_stop (seat);

            }

        }

    }

    g_object_unref (display_server);

}

static gboolean

can_share_display_server (Seat *seat, DisplayServer *display_server)

{

    return seat->priv->share_display_server && display_server_get_can_share (display_server);

}

static GreeterSession *

find_greeter_session (Seat *seat)

{

    GList *link;

    for (link = seat->priv->sessions; link; link = link->next)

    {

        Session *session = link->data;

        if (!session_get_is_stopping (session) && IS_GREETER_SESSION (session))

            return GREETER_SESSION (session);

    }

    return NULL;

}

static GreeterSession *

find_resettable_greeter (Seat *seat)

{

    GList *link;

    for (link = seat->priv->sessions; link; link = link->next)

    {

        Session *session = link->data;

        if (!session_get_is_stopping (session) && IS_GREETER_SESSION (session) &&

            greeter_get_resettable (greeter_session_get_greeter (GREETER_SESSION (session))))

            return GREETER_SESSION (session);

    }

    return NULL;

}

static void

set_greeter_hints (Seat *seat, Greeter *greeter)

{

    greeter_clear_hints (greeter);

    greeter_set_hint (greeter, "default-session", seat_get_string_property (seat, "user-session"));

    greeter_set_hint (greeter, "hide-users", seat_get_boolean_property (seat, "greeter-hide-users") ? "true" : "false");

    greeter_set_hint (greeter, "show-manual-login", seat_get_boolean_property (seat, "greeter-show-manual-login") ? "true" : "false");

    greeter_set_hint (greeter, "show-remote-login", seat_get_boolean_property (seat, "greeter-show-remote-login") ? "true" : "false");

    greeter_set_hint (greeter, "has-guest-account", seat_get_allow_guest (seat) && seat_get_boolean_property (seat, "greeter-allow-guest") ? "true" : "false");

}

static void

switch_to_greeter_from_failed_session (Seat *seat, Session *session)

{

    GreeterSession *greeter_session;

    Greeter *greeter;  

    gboolean existing = FALSE;

    /* Switch to greeter if one open */

    greeter_session = find_resettable_greeter (seat);

    if (greeter_session)

    {

        l_debug (seat, "Switching to existing greeter");

        set_greeter_hints (seat, greeter_session_get_greeter (greeter_session));

        existing = TRUE;

    }

    else

    {

        greeter_session = create_greeter_session (seat);

    }

    greeter = greeter_session_get_greeter (greeter_session);

    if (session_get_is_guest (session))

        greeter_set_hint (greeter, "select-guest", "true");

    else

        greeter_set_hint (greeter, "select-user", session_get_username (session));

    if (existing)

    {

        greeter_reset (greeter);

        seat_set_active_session (seat, SESSION (greeter_session));

    }

    else

    {

        g_clear_object (&seat->priv->session_to_activate);

        seat->priv->session_to_activate = g_object_ref (greeter_session);

        if (can_share_display_server (seat, session_get_display_server (session)))

            session_set_display_server (SESSION (greeter_session), session_get_display_server (session));

        else

        {

            DisplayServer *display_server;

            display_server = create_display_server (seat, session);

            session_set_display_server (session, display_server);

            if (!start_display_server (seat, display_server))

            {

                l_debug (seat, "Failed to start display server for greeter");

                seat_stop (seat);

            }

        }

        start_session (seat, SESSION (greeter_session));

    }

    /* Stop failed session */

    session_stop (session);

}

static void

start_session (Seat *seat, Session *session)

{

    /* Use system location for greeter log file */

    if (IS_GREETER_SESSION (session))

    {

        gchar *log_dir, *filename, *log_filename;

        gboolean backup_logs;

        log_dir = config_get_string (config_get_instance (), "LightDM", "log-directory");

        filename = g_strdup_printf ("%s-greeter.log", seat->priv->name);

        log_filename = g_build_filename (log_dir, filename, NULL);

        g_free (log_dir);

        g_free (filename);

        backup_logs = config_get_boolean (config_get_instance (), "LightDM", "backup-logs");

        session_set_log_file (session, log_filename, backup_logs ? LOG_MODE_BACKUP_AND_TRUNCATE : LOG_MODE_APPEND);

        g_free (log_filename);

    }

    if (session_start (session))

        return;

    if (IS_GREETER_SESSION (session))

    {

        l_debug (seat, "Failed to start greeter");

        display_server_stop (session_get_display_server (session));

        return;

    }

    l_debug (seat, "Failed to start session, starting greeter");

    switch_to_greeter_from_failed_session (seat, session);

}

static void

run_session (Seat *seat, Session *session)

{

    const gchar *script;