src/seat.c

   1 /*
   2  * Copyright (C) 2010-2011 Robert Ancell.
   3  * Author: Robert Ancell <robert.ancell@canonical.com>
   4  *
   5  * This program is free software: you can redistribute it and/or modify it under
   6  * the terms of the GNU General Public License as published by the Free Software
   7  * Foundation, either version 3 of the License, or (at your option) any later
   8  * version. See http://www.gnu.org/copyleft/gpl.html the full text of the
   9  * license.
  10  */
  11
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <sys/wait.h>
  15
  16 #include "seat.h"
  17 #include "configuration.h"
  18 #include "guest-account.h"
  19 #include "greeter.h"
  20
  21 enum {
  22     SESSION_ADDED,
  23     SESSION_REMOVED,
  24     STOPPED,
  25     LAST_SIGNAL
  26 };
  27 static guint signals[LAST_SIGNAL] = { 0 };
  28
  29 struct SeatPrivate
  30 {
  31     /* Configuration for this seat */
  32     GHashTable *properties;
  33
  34     /* TRUE if able to switch users */
  35     gboolean can_switch;
  36
  37     /* TRUE if display server can be shared for sessions */
  38     gboolean share_display_server;
  39
  40     /* The display servers on this seat */
  41     GList *display_servers;
  42
  43     /* The sessions on this seat */
  44     GList *sessions;
  45
  46     /* The session to set active when it starts */
  47     Session *session_to_activate;
  48
  49     /* TRUE if stopping this seat (waiting for displays to stop) */
  50     gboolean stopping;
  51
  52     /* TRUE if stopped */
  53     gboolean stopped;
  54 };
  55
  56 /* PAM services to use */
  57 #define GREETER_SERVICE   "lightdm-greeter"
  58 #define USER_SERVICE      "lightdm"
  59 #define AUTOLOGIN_SERVICE "lightdm-autologin"
  60
  61 G_DEFINE_TYPE (Seat, seat, G_TYPE_OBJECT);
  62
  63 typedef struct
  64 {
  65     const gchar *name;
  66     GType type;
  67 } SeatModule;
  68 static GHashTable *seat_modules = NULL;
  69
  70 // FIXME: Make a get_display_server() that re-uses display servers if supported
  71 static DisplayServer *create_display_server (Seat *seat);
  72 static Greeter *create_greeter_session (Seat *seat);
  73
  74 void
  75 seat_register_module (const gchar *name, GType type)
  76 {
  77     SeatModule *module;
  78
  79     if (!seat_modules)
  80         seat_modules = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
  81
  82     g_debug ("Registered seat module %s", name);
  83
  84     module = g_malloc0 (sizeof (SeatModule));
  85     module->name = g_strdup (name);
  86     module->type = type;
  87     g_hash_table_insert (seat_modules, g_strdup (name), module);
  88 }
  89
  90 Seat *
  91 seat_new (const gchar *module_name)
  92 {
  93     Seat *seat;
  94     SeatModule *m = NULL;
  95
  96     g_return_val_if_fail (module_name != NULL, NULL);
  97
  98     if (seat_modules)
  99         m = g_hash_table_lookup (seat_modules, module_name);
 100     if (!m)
 101         return NULL;
 102
 103     seat = g_object_new (m->type, NULL);
 104
 105     return seat;
 106 }
 107
 108 void
 109 seat_set_property (Seat *seat, const gchar *name, const gchar *value)
 110 {
 111     g_return_if_fail (seat != NULL);
 112     g_hash_table_insert (seat->priv->properties, g_strdup (name), g_strdup (value));
 113 }
 114
 115 const gchar *
 116 seat_get_string_property (Seat *seat, const gchar *name)
 117 {
 118     g_return_val_if_fail (seat != NULL, NULL);
 119     return g_hash_table_lookup (seat->priv->properties, name);
 120 }
 121
 122 gboolean
 123 seat_get_boolean_property (Seat *seat, const gchar *name)
 124 {
 125     return g_strcmp0 (seat_get_string_property (seat, name), "true") == 0;
 126 }
 127
 128 gint
 129 seat_get_integer_property (Seat *seat, const gchar *name)
 130 {
 131     const gchar *value;
 132
 133     value = seat_get_string_property (seat, name);
 134     return value ? atoi (value) : 0;
 135 }
 136
 137 void
 138 seat_set_can_switch (Seat *seat, gboolean can_switch)
 139 {
 140     g_return_if_fail (seat != NULL);
 141
 142     seat->priv->can_switch = can_switch;
 143 }
 144
 145 void
 146 seat_set_share_display_server (Seat *seat, gboolean share_display_server)
 147 {
 148     g_return_if_fail (seat != NULL);
 149
 150     seat->priv->share_display_server = share_display_server;
 151 }
 152
 153 gboolean
 154 seat_start (Seat *seat)
 155 {
 156     g_return_val_if_fail (seat != NULL, FALSE);
 157
 158     SEAT_GET_CLASS (seat)->setup (seat);
 159     return SEAT_GET_CLASS (seat)->start (seat);
 160 }
 161
 162 GList *
 163 seat_get_sessions (Seat *seat)
 164 {
 165     g_return_val_if_fail (seat != NULL, NULL);
 166     return seat->priv->sessions;
 167 }
 168
 169 void
 170 seat_set_active_session (Seat *seat, Session *session)
 171 {
 172     GList *link;
 173
 174     g_return_if_fail (seat != NULL);
 175
 176     SEAT_GET_CLASS (seat)->set_active_session (seat, session);
 177
 178     /* Stop any greeters */
 179     for (link = seat->priv->sessions; link; link = link->next)
 180     {
 181         Session *s = link->data;
 182
 183         if (s == session || session_get_is_stopping (s))
 184             continue;
 185
 186         if (IS_GREETER (s))
 187         {
 188             g_debug ("Stopping greeter");
 189             session_stop (s);
 190         }
 191     }
 192 }
 193
 194 Session *
 195 seat_get_active_session (Seat *seat)
 196 {
 197     g_return_val_if_fail (seat != NULL, NULL);
 198     return SEAT_GET_CLASS (seat)->get_active_session (seat);
 199 }
 200
 201 gboolean
 202 seat_get_can_switch (Seat *seat)
 203 {
 204     g_return_val_if_fail (seat != NULL, FALSE);
 205     return seat->priv->can_switch;
 206 }
 207
 208 gboolean
 209 seat_get_allow_guest (Seat *seat)
 210 {
 211     g_return_val_if_fail (seat != NULL, FALSE);
 212     return seat_get_boolean_property (seat, "allow-guest") && guest_account_is_installed ();
 213 }
 214
 215 gboolean
 216 seat_get_greeter_allow_guest (Seat *seat)
 217 {
 218     g_return_val_if_fail (seat != NULL, FALSE);
 219     return seat_get_allow_guest (seat) && seat_get_boolean_property (seat, "greeter-allow-guest");
 220 }
 221
 222 static gboolean
 223 run_script (Seat *seat, DisplayServer *display_server, const gchar *script_name, User *user)
 224 {
 225     Process *script;
 226     gboolean result = FALSE;
 227
 228     script = process_new ();
 229
 230     process_set_command (script, script_name);
 231
 232     /* Set POSIX variables */
 233     process_set_clear_environment (script, TRUE);
 234     process_set_env (script, "SHELL", "/bin/sh");
 235
 236     /* Variables required for regression tests */
 237     if (g_getenv ("LIGHTDM_TEST_ROOT"))
 238     {
 239         process_set_env (script, "LIGHTDM_TEST_ROOT", g_getenv ("LIGHTDM_TEST_ROOT"));
 240         process_set_env (script, "LD_PRELOAD", g_getenv ("LD_PRELOAD"));
 241         process_set_env (script, "LD_LIBRARY_PATH", g_getenv ("LD_LIBRARY_PATH"));
 242         process_set_env (script, "PATH", g_getenv ("PATH"));
 243     }
 244     else
 245         process_set_env (script, "PATH", "/usr/local/bin:/usr/bin:/bin");
 246
 247     if (user)
 248     {
 249         process_set_env (script, "USER", user_get_name (user));
 250         process_set_env (script, "LOGNAME", user_get_name (user));
 251         process_set_env (script, "HOME", user_get_home_directory (user));
 252     }
 253     else
 254         process_set_env (script, "HOME", "/");
 255
 256     SEAT_GET_CLASS (seat)->run_script (seat, display_server, script);
 257
 258     if (process_start (script, TRUE))
 259     {
 260         int exit_status;
 261
 262         exit_status = process_get_exit_status (script);
 263         if (WIFEXITED (exit_status))
 264         {
 265             g_debug ("Exit status of %s: %d", script_name, WEXITSTATUS (exit_status));
 266             result = WEXITSTATUS (exit_status) == EXIT_SUCCESS;
 267         }
 268     }
 269
 270     g_object_unref (script);
 271
 272     return result;
 273 }
 274
 275 static void
 276 seat_real_run_script (Seat *seat, DisplayServer *display_server, Process *process)
 277 {
 278 }
 279
 280 static void
 281 emit_upstart_signal (const gchar *signal)
 282 {
 283     g_return_if_fail (signal != NULL);
 284     g_return_if_fail (signal[0] != 0);
 285
 286     if (getuid () != 0)
 287         return;
 288
 289     gchar *cmd = g_strdup_printf ("initctl -q emit %s DISPLAY_MANAGER=lightdm", signal);
 290     g_spawn_command_line_async (cmd, NULL); /* OK if it fails, probably not installed */
 291     g_free (cmd);
 292 }
 293
 294 static void
 295 check_stopped (Seat *seat)
 296 {
 297     if (seat->priv->stopping &&
 298         !seat->priv->stopped &&
 299         g_list_length (seat->priv->display_servers) == 0 &&
 300         g_list_length (seat->priv->sessions) == 0)
 301     {
 302         seat->priv->stopped = TRUE;
 303         g_debug ("Seat stopped");
 304         g_signal_emit (seat, signals[STOPPED], 0);
 305     }
 306 }
 307
 308 static void
 309 display_server_stopped_cb (DisplayServer *display_server, Seat *seat)
 310 {
 311     GList *link;
 312     Session *active_session;
 313
 314     g_debug ("Display server stopped");
 315
 316     g_signal_handlers_disconnect_matched (display_server, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, seat);
 317     seat->priv->display_servers = g_list_remove (seat->priv->display_servers, display_server);
 318
 319     if (seat->priv->stopping)
 320     {
 321         check_stopped (seat);
 322         g_object_unref (display_server);
 323         return;
 324     }
 325
 326     /* Stop all sessions on this display server */
 327     for (link = seat->priv->sessions; link; link = link->next)
 328     {
 329         Session *session = link->data;
 330
 331         if (session_get_display_server (session) != display_server || session_get_is_stopping (session))
 332             continue;
 333
 334         /* Stop seat if this is the only display server and it failed to start a greeter */
 335         if (IS_GREETER (session) &&
 336             !session_get_is_started (session) &&
 337             g_list_length (seat->priv->display_servers) == 0)
 338         {
 339             g_debug ("Stopping seat, greeter display server failed to start");
 340             seat_stop (seat);
 341         }
 342
 343         g_debug ("Stopping session");
 344         session_stop (session);
 345     }
 346
 347     /* If we were the active session, switch to a greeter */
 348     active_session = seat_get_active_session (seat);
 349     if (!active_session || session_get_display_server (active_session) == display_server)
 350     {
 351         g_debug ("Active display server stopped, starting greeter");
 352         seat_switch_to_greeter (seat);
 353     }
 354
 355     g_object_unref (display_server);
 356 }
 357
 358 static void
 359 start_session (Seat *seat, Session *session)
 360 {
 361     Greeter *greeter_session;
 362
 363     if (session_start (session))
 364         return;
 365
 366     if (IS_GREETER (session))
 367     {
 368         g_debug ("Failed to start greeter");
 369         display_server_stop (session_get_display_server (session));
 370         return;
 371     }
 372
 373     g_debug ("Failed to start session, starting greeter");
 374     greeter_session = create_greeter_session (seat);
 375     if (seat->priv->session_to_activate)
 376         g_object_unref (seat->priv->session_to_activate);
 377     seat->priv->session_to_activate = g_object_ref (greeter_session);
 378
 379     if (seat->priv->share_display_server)
 380         session_set_display_server (SESSION (greeter_session), session_get_display_server (session));
 381     else
 382     {
 383         DisplayServer *display_server;
 384
 385         display_server = create_display_server (seat);
 386         if (!display_server_start (display_server))
 387         {
 388             g_debug ("Failed to start display server for greeter");
 389             seat_stop (seat);
 390         }
 391
 392         session_set_display_server (session, display_server);
 393     }
 394
 395     start_session (seat, SESSION (greeter_session));
 396 }
 397
 398 static void
 399 run_session (Seat *seat, Session *session)
 400 {
 401     const gchar *script;
 402
 403     if (IS_GREETER (session))
 404         script = seat_get_string_property (seat, "greeter-setup-script");
 405     else
 406         script = seat_get_string_property (seat, "session-setup-script");
 407     if (script && !run_script (seat, session_get_display_server (session), script, NULL))
 408     {
 409         Greeter *greeter_session;
 410
 411         g_debug ("Switching to greeter due to failed setup script");
 412
 413         // FIXME: Only if can share servers
 414
 415         greeter_session = create_greeter_session (seat);
 416         if (seat->priv->session_to_activate)
 417             g_object_unref (seat->priv->session_to_activate);
 418         seat->priv->session_to_activate = g_object_ref (greeter_session);
 419         session_set_display_server (SESSION (greeter_session), session_get_display_server (session));
 420
 421         start_session (seat, SESSION (greeter_session));
 422
 423         /* Stop failed session */
 424         session_stop (session);
 425
 426         return;
 427     }
 428
 429     session_run (session);
 430
 431     // FIXME: Wait until the session is ready
 432
 433     if (session == seat->priv->session_to_activate)
 434     {
 435         seat_set_active_session (seat, session);
 436         g_object_unref (seat->priv->session_to_activate);
 437         seat->priv->session_to_activate = NULL;
 438     }
 439 }
 440
 441 static void
 442 session_authentication_complete_cb (Session *session, Seat *seat)
 443 {
 444     if (session_get_is_authenticated (session))
 445     {
 446         g_debug ("Session authenticated, running command");
 447         run_session (seat, session);
 448     }
 449     else if (!IS_GREETER (session))
 450     {
 451         Greeter *greeter_session;
 452
 453         g_debug ("Switching to greeter due to failed authentication");
 454
 455         greeter_session = create_greeter_session (seat);
 456         if (seat->priv->session_to_activate)
 457             g_object_unref (seat->priv->session_to_activate);
 458         seat->priv->session_to_activate = g_object_ref (greeter_session);
 459         if (session_get_is_guest (session))
 460             greeter_set_hint (greeter_session, "select-guest", "true");
 461         else
 462             greeter_set_hint (greeter_session, "select-user", session_get_username (session));
 463
 464         if (seat->priv->share_display_server)
 465             session_set_display_server (SESSION (greeter_session), session_get_display_server (session));
 466         else
 467         {
 468             DisplayServer *display_server;
 469
 470             display_server = create_display_server (seat);
 471             if (!display_server_start (display_server))
 472             {
 473                 g_debug ("Failed to start display server for greeter");
 474                 seat_stop (seat);
 475             }
 476
 477             session_set_display_server (SESSION (greeter_session), display_server);
 478         }
 479
 480         start_session (seat, SESSION (greeter_session));
 481
 482         /* Stop failed session */
 483         session_stop (session);
 484     }
 485     else
 486     {
 487         g_debug ("Stopping session that failed authentication");
 488         session_stop (session);
 489     }
 490 }
 491
 492 static void
 493 session_stopped_cb (Session *session, Seat *seat)
 494 {
 495     DisplayServer *display_server;
 496
 497     g_debug ("Session stopped");
 498
 499     display_server = session_get_display_server (session);
 500
 501     /* Cleanup */
 502     if (!IS_GREETER (session))
 503     {
 504         const gchar *script;
 505         script = seat_get_string_property (seat, "session-cleanup-script");
 506         if (script)
 507             run_script (seat, display_server, script, session_get_user (session));
 508     }
 509
 510     g_signal_handlers_disconnect_matched (session, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, seat);
 511     seat->priv->sessions = g_list_remove (seat->priv->sessions, session);
 512
 513     /* We were waiting for this session, but it didn't start :( */
 514     // FIXME: Start a greeter on this?
 515     if (session == seat->priv->session_to_activate)
 516     {
 517         g_object_unref (seat->priv->session_to_activate);
 518         seat->priv->session_to_activate = NULL;
 519     }
 520
 521     if (seat->priv->stopping)
 522     {
 523         check_stopped (seat);
 524         g_object_unref (session);
 525         return;
 526     }
 527
 528     /* If this is the greeter session then re-use this display server */
 529     if (IS_GREETER (session) && seat->priv->share_display_server &&
 530         greeter_get_start_session (GREETER (session)))
 531     {
 532         GList *link;
 533
 534         for (link = seat->priv->sessions; link; link = link->next)
 535         {
 536             Session *s = link->data;
 537
 538             /* Skip this session and sessions on other display servers */
 539             if (s == session || session_get_display_server (s) != display_server || session_get_is_stopping (s))
 540                 continue;
 541
 542             if (session_get_is_authenticated (s))
 543             {
 544                 g_debug ("Greeter stopped, running session");
 545                 run_session (seat, s);
 546             }
 547             else
 548             {
 549                 g_debug ("Greeter stopped, starting session authentication");
 550                 start_session (seat, s);
 551             }
 552             break;
 553         }
 554     }
 555     /* If this is the greeter and nothing else is running then stop the seat */
 556     else if (IS_GREETER (session) &&
 557         !greeter_get_start_session (GREETER (session)) &&
 558         g_list_length (seat->priv->display_servers) == 1 &&
 559         g_list_nth_data (seat->priv->display_servers, 0) == display_server)
 560     {
 561         g_debug ("Stopping seat, failed to start a greeter");
 562         seat_stop (seat);
 563     }
 564     /* If we were the active session, switch to a greeter */
 565     else if (!IS_GREETER (session) && session == seat_get_active_session (seat))
 566     {
 567         g_debug ("Active session stopped, starting greeter");
 568         seat_switch_to_greeter (seat);
 569     }
 570
 571     /* Stop the display server if no-longer required */
 572     if (display_server && !display_server_get_is_stopping (display_server))
 573     {
 574         GList *link;
 575         int n_sessions = 0;
 576
 577         for (link = seat->priv->sessions; link; link = link->next)
 578         {
 579             Session *s = link->data;
 580             if (s == session)
 581                 continue;
 582             if (session_get_display_server (s) == display_server)
 583                 n_sessions++;
 584         }
 585         if (n_sessions == 0)
 586         {
 587             g_debug ("Stopping display server, no sessions require it");
 588             display_server_stop (display_server);
 589         }
 590     }
 591
 592     g_object_unref (session);
 593 }
 594
 595 static void
 596 set_session_env (Session *session)
 597 {
 598     /* Variables required for regression tests */
 599     if (g_getenv ("LIGHTDM_TEST_ROOT"))
 600     {
 601         session_set_env (session, "LIGHTDM_TEST_ROOT", g_getenv ("LIGHTDM_TEST_ROOT"));
 602         session_set_env (session, "DBUS_SYSTEM_BUS_ADDRESS", g_getenv ("DBUS_SYSTEM_BUS_ADDRESS"));
 603         session_set_env (session, "DBUS_SESSION_BUS_ADDRESS", g_getenv ("DBUS_SESSION_BUS_ADDRESS"));
 604         session_set_env (session, "LD_PRELOAD", g_getenv ("LD_PRELOAD"));
 605         session_set_env (session, "LD_LIBRARY_PATH", g_getenv ("LD_LIBRARY_PATH"));
 606         session_set_env (session, "GI_TYPELIB_PATH", g_getenv ("GI_TYPELIB_PATH"));
 607     }
 608 }
 609
 610 static Session *
 611 create_session (Seat *seat, gboolean autostart)
 612 {
 613     Session *session;
 614
 615     session = SEAT_GET_CLASS (seat)->create_session (seat);
 616     seat->priv->sessions = g_list_append (seat->priv->sessions, session);
 617     if (autostart)
 618         g_signal_connect (session, "authentication-complete", G_CALLBACK (session_authentication_complete_cb), seat);
 619     g_signal_connect (session, "stopped", G_CALLBACK (session_stopped_cb), seat);
 620
 621     set_session_env (session);
 622
 623     return session;
 624 }
 625
 626 static gchar **
 627 get_session_argv_from_filename (const gchar *filename, const gchar *session_wrapper)
 628 {
 629     GKeyFile *session_desktop_file;
 630     gboolean result;
 631     int argc;
 632     gchar *command = NULL, **argv, *path;
 633     GError *error = NULL;
 634
 635     /* Read the command from the .desktop file */
 636     session_desktop_file = g_key_file_new ();
 637     result = g_key_file_load_from_file (session_desktop_file, filename, G_KEY_FILE_NONE, &error);
 638     if (error)
 639         g_debug ("Failed to load session file %s: %s", filename, error->message);
 640     g_clear_error (&error);
 641     if (result)
 642     {
 643         command = g_key_file_get_string (session_desktop_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_EXEC, NULL);
 644         if (!command)
 645             g_debug ("No command in session file %s", filename);
 646     }
 647     g_key_file_free (session_desktop_file);
 648
 649     if (!command)
 650         return NULL;
 651
 652     /* If configured, run sessions through a wrapper */
 653     if (session_wrapper)
 654     {
 655         argv = g_malloc (sizeof (gchar *) * 3);
 656         path = g_find_program_in_path (session_wrapper);
 657         argv[0] = path ? path : g_strdup (session_wrapper);
 658         argv[1] = command;
 659         argv[2] = NULL;
 660         return argv;
 661     }
 662
 663     /* Split command into an array listing and make command absolute */
 664     result = g_shell_parse_argv (command, &argc, &argv, &error);
 665     if (error)
 666         g_debug ("Invalid session command '%s': %s", command, error->message);
 667     g_clear_error (&error);
 668     g_free (command);
 669     if (!result)
 670         return NULL;
 671     path = g_find_program_in_path (argv[0]);
 672     if (path)
 673     {
 674         g_free (argv[0]);
 675         argv[0] = path;
 676     }
 677
 678     return argv;
 679 }
 680
 681 static gchar **
 682 get_session_argv (const gchar *sessions_dir, const gchar *session_name, const gchar *session_wrapper)
 683 {
 684     gchar **dirs, **argv;
 685     int i;
 686
 687     g_return_val_if_fail (sessions_dir != NULL, NULL);
 688     g_return_val_if_fail (session_name != NULL, NULL);
 689
 690     dirs = g_strsplit (sessions_dir, ":", -1);
 691     for (i = 0; dirs[i]; i++)
 692     {
 693         gchar *filename, *path;
 694
 695         filename = g_strdup_printf ("%s.desktop", session_name);
 696         path = g_build_filename (dirs[i], filename, NULL);
 697         g_free (filename);
 698         argv = get_session_argv_from_filename (path, session_wrapper);
 699         g_free (path);
 700         if (argv)
 701             break;
 702     }
 703     g_strfreev (dirs);
 704
 705     return argv;
 706 }
 707
 708 static Session *
 709 create_user_session (Seat *seat, const gchar *username)
 710 {
 711     User *user;
 712     gchar *sessions_dir, **argv;
 713     const gchar *session_name;
 714     Session *session;
 715
 716     user = accounts_get_user_by_name (username);
 717     if (!user)
 718     {
 719         g_debug ("Can't login unknown user '%s'", username);
 720         return NULL;
 721     }
 722
 723     session_name = user_get_xsession (user);
 724     g_object_unref (user);
 725     if (!session_name)
 726         session_name = seat_get_string_property (seat, "user-session");
 727     sessions_dir = config_get_string (config_get_instance (), "LightDM", "sessions-directory");
 728     argv = get_session_argv (sessions_dir, session_name, seat_get_string_property (seat, "session-wrapper"));
 729     g_free (sessions_dir);
 730     if (!argv)
 731     {
 732         g_debug ("Can't find session '%s'", seat_get_string_property (seat, "user-session"));
 733         return NULL;
 734     }
 735
 736     session = create_session (seat, TRUE);
 737     session_set_pam_service (session, AUTOLOGIN_SERVICE);
 738     session_set_username (session, username);
 739     session_set_do_authenticate (session, TRUE);
 740     session_set_argv (session, argv);
 741
 742     return session;
 743 }
 744
 745 static Session *
 746 create_guest_session (Seat *seat)
 747 {
 748     gchar *sessions_dir, **argv;
 749     Session *session;
 750
 751     sessions_dir = config_get_string (config_get_instance (), "LightDM", "sessions-directory");
 752     argv = get_session_argv (sessions_dir,
 753                              seat_get_string_property (seat, "user-session"),
 754                              seat_get_string_property (seat, "session-wrapper"));
 755     g_free (sessions_dir);
 756     if (!argv)
 757     {
 758         g_debug ("Can't find session '%s'", seat_get_string_property (seat, "user-session"));
 759         return NULL;
 760     }
 761
 762     session = create_session (seat, TRUE);
 763     session_set_do_authenticate (session, TRUE);
 764     session_set_is_guest (session, TRUE);
 765     session_set_argv (session, argv);
 766
 767     return session;
 768 }
 769
 770 static Session *
 771 greeter_create_session_cb (Greeter *greeter, Seat *seat)
 772 {
 773     Session *session;
 774
 775     session = create_session (seat, FALSE);
 776     session_set_display_server (session, session_get_display_server (SESSION (greeter)));
 777
 778     return g_object_ref (session);
 779 }
 780
 781 static void
 782 prepend_argv (gchar ***argv, const gchar *value)
 783 {
 784     gchar **old_argv, **new_argv;
 785     gint i;
 786
 787     old_argv = *argv;
 788     new_argv = g_malloc (sizeof (gchar *) * (g_strv_length (*argv) + 2));
 789     new_argv[0] = g_strdup (value);
 790     for (i = 0; old_argv[i]; i++)
 791         new_argv[i + 1] = old_argv[i];
 792     new_argv[i + 1] = NULL;
 793
 794     g_free (*argv);
 795     *argv = new_argv;
 796 }
 797
 798 static Session *
 799 find_user_session (Seat *seat, const gchar *username)
 800 {
 801     GList *link;
 802
 803     if (!username)
 804         return NULL;
 805
 806     for (link = seat->priv->sessions; link; link = link->next)
 807     {
 808         Session *session = link->data;
 809
 810         if (!session_get_is_stopping (session) && strcmp (session_get_username (session), username) == 0)
 811             return session;
 812     }
 813
 814     return NULL;
 815 }
 816
 817 static gboolean
 818 greeter_start_session_cb (Greeter *greeter, SessionType type, const gchar *session_name, Seat *seat)
 819 {
 820     Session *session, *existing_session;
 821     const gchar *username;
 822     User *user;
 823     gchar *sessions_dir = NULL;
 824     gchar **argv;
 825
 826     /* Get the session to use */
 827     if (greeter_get_guest_authenticated (greeter))
 828     {
 829         session = create_guest_session (seat);
 830         session_set_pam_service (session, AUTOLOGIN_SERVICE);
 831     }
 832     else
 833         session = greeter_get_authentication_session (greeter);
 834
 835     /* Switch to this session when it is ready */
 836     if (seat->priv->session_to_activate)
 837         g_object_unref (seat->priv->session_to_activate);
 838     seat->priv->session_to_activate = g_object_ref (session);
 839
 840     /* Return to existing session if it is open */
 841     username = session_get_username (session);
 842     existing_session = find_user_session (seat, username);
 843     if (existing_session && session != existing_session)
 844     {
 845         g_debug ("Returning to existing user session %s", username);
 846         session_stop (session);
 847         seat_set_active_session (seat, existing_session);
 848         return TRUE;
 849     }
 850
 851     /* Get session command to run */
 852     switch (type)
 853     {
 854     case SESSION_TYPE_LOCAL:
 855         sessions_dir = config_get_string (config_get_instance (), "LightDM", "sessions-directory");
 856         break;
 857     case SESSION_TYPE_REMOTE:
 858         sessions_dir = config_get_string (config_get_instance (), "LightDM", "remote-sessions-directory");
 859         break;
 860     }
 861     user = session_get_user (session);
 862     if (!session_name && user)
 863         session_name = user_get_xsession (user);
 864     if (!session_name)
 865         session_name = seat_get_string_property (seat, "user-session");
 866     if (user)
 867         user_set_xsession (session_get_user (session), session_name);
 868     argv = get_session_argv (sessions_dir, session_name, seat_get_string_property (seat, "session-wrapper"));
 869     g_free (sessions_dir);
 870
 871     if (!argv)
 872     {
 873         g_debug ("Can't find session '%s'", seat_get_string_property (seat, "user-session"));
 874         return FALSE;
 875     }
 876
 877     session_set_argv (session, argv);
 878     g_strfreev (argv);
 879
 880     /* If no session information found, then can't start the session */
 881     if (!argv)
 882     {
 883         g_debug ("Can't find greeter session '%s'", session_name);
 884         return FALSE;
 885     }
 886
 887     /* If can re-use the display server, stop the greeter first */
 888     if (seat->priv->share_display_server)
 889     {
 890         /* Run on the same display server after the greeter has stopped */
 891         session_set_display_server (session, session_get_display_server (SESSION (greeter)));
 892
 893         g_debug ("Stopping greeter");
 894         session_stop (SESSION (greeter));
 895
 896         return TRUE;
 897     }
 898     /* Otherwise start a new display server for this session */
 899     else
 900     {
 901         DisplayServer *display_server;
 902
 903         display_server = create_display_server (seat);
 904         if (!display_server_start (display_server))
 905             return FALSE;
 906
 907         session_set_display_server (session, display_server);
 908
 909         return TRUE;
 910     }
 911 }
 912
 913 static Greeter *
 914 create_greeter_session (Seat *seat)
 915 {
 916     gchar *sessions_dir, **argv;
 917     Greeter *greeter_session;
 918     gchar *greeter_user;
 919     const gchar *greeter_wrapper;
 920
 921     sessions_dir = config_get_string (config_get_instance (), "LightDM", "greeters-directory");
 922     argv = get_session_argv (sessions_dir,
 923                              seat_get_string_property (seat, "greeter-session"),
 924                              seat_get_string_property (seat, "session-wrapper"));
 925     g_free (sessions_dir);
 926     if (!argv)
 927         return NULL;
 928
 929     greeter_wrapper = seat_get_string_property (seat, "greeter-wrapper");
 930     if (greeter_wrapper)
 931     {
 932         gchar *path;
 933         path = g_find_program_in_path (greeter_wrapper);
 934         prepend_argv (&argv, path ? path : greeter_wrapper);
 935         g_free (path);
 936     }
 937
 938     greeter_session = SEAT_GET_CLASS (seat)->create_greeter_session (seat);
 939     seat->priv->sessions = g_list_append (seat->priv->sessions, SESSION (greeter_session));
 940     g_signal_connect (greeter_session, "authentication-complete", G_CALLBACK (session_authentication_complete_cb), seat);
 941     g_signal_connect (greeter_session, "stopped", G_CALLBACK (session_stopped_cb), seat);
 942
 943     set_session_env (SESSION (greeter_session));
 944
 945     session_set_pam_service (SESSION (greeter_session), GREETER_SERVICE);
 946     greeter_user = config_get_string (config_get_instance (), "LightDM", "greeter-user");
 947     session_set_username (SESSION (greeter_session), greeter_user);
 948     g_free (greeter_user);
 949     session_set_argv (SESSION (greeter_session), argv);
 950
 951     greeter_set_pam_services (greeter_session, USER_SERVICE, AUTOLOGIN_SERVICE);
 952     greeter_set_allow_guest (greeter_session, seat_get_allow_guest (seat));
 953     g_signal_connect (greeter_session, "create-session", G_CALLBACK (greeter_create_session_cb), seat);
 954     g_signal_connect (greeter_session, "start-session", G_CALLBACK (greeter_start_session_cb), seat);
 955
 956     return greeter_session;
 957 }
 958
 959 static void
 960 display_server_ready_cb (DisplayServer *display_server, Seat *seat)
 961 {
 962     const gchar *script;
 963     GList *link;
 964     gboolean used_display_server = FALSE;
 965
 966     /* Run setup script */
 967     script = seat_get_string_property (seat, "display-setup-script");
 968     if (script && !run_script (seat, display_server, script, NULL))
 969     {
 970         g_debug ("Stopping display server due to failed setup script");
 971         display_server_stop (display_server);
 972         return;
 973     }
 974
 975     emit_upstart_signal ("login-session-start");
 976
 977     /* Start the sessions waiting for this display server */
 978     for (link = seat->priv->sessions; link; link = link->next)
 979     {
 980         Session *session = link->data;
 981
 982         if (session_get_display_server (session) != display_server || session_get_is_stopping (session))
 983             continue;
 984
 985         if (session_get_is_authenticated (session))
 986         {
 987             g_debug ("Display server ready, running session");
 988             run_session (seat, session);
 989         }
 990         else
 991         {
 992             g_debug ("Display server ready, starting session authentication");
 993             // FIXME: Can modify sessions
 994             start_session (seat, session);
 995         }
 996         used_display_server = TRUE;
 997     }
 998
 999     if (!used_display_server)
1000     {
1001         g_debug ("Stopping not required display server");
1002         display_server_stop (display_server);
1003     }
1004 }
1005
1006 static DisplayServer *
1007 create_display_server (Seat *seat)
1008 {
1009     DisplayServer *display_server;
1010
1011     display_server = SEAT_GET_CLASS (seat)->create_display_server (seat);
1012     seat->priv->display_servers = g_list_append (seat->priv->display_servers, display_server);
1013     g_signal_connect (display_server, "ready", G_CALLBACK (display_server_ready_cb), seat);
1014     g_signal_connect (display_server, "stopped", G_CALLBACK (display_server_stopped_cb), seat);
1015
1016     return display_server;
1017 }
1018
1019 static Greeter *
1020 find_greeter_session (Seat *seat)
1021 {
1022     GList *link;
1023
1024     for (link = seat->priv->sessions; link; link = link->next)
1025     {
1026         Session *session = link->data;
1027         if (!session_get_is_stopping (session) && IS_GREETER (session))
1028             return GREETER (session);
1029     }
1030
1031     return NULL;
1032 }
1033
1034 gboolean
1035 seat_switch_to_greeter (Seat *seat)
1036 {
1037     Greeter *greeter_session;
1038     DisplayServer *display_server;
1039
1040     g_return_val_if_fail (seat != NULL, FALSE);
1041
1042     if (!seat->priv->can_switch)
1043         return FALSE;
1044
1045     /* Switch to greeter if one open (shouldn't be though) */
1046     greeter_session = find_greeter_session (seat);
1047     if (greeter_session)
1048     {
1049         g_debug ("Switching to existing greeter");
1050         seat_set_active_session (seat, SESSION (greeter_session));
1051         return TRUE;
1052     }
1053
1054     greeter_session = create_greeter_session (seat);
1055     if (seat->priv->session_to_activate)
1056         g_object_unref (seat->priv->session_to_activate);
1057     seat->priv->session_to_activate = g_object_ref (greeter_session);
1058
1059     display_server = create_display_server (seat);
1060     session_set_display_server (SESSION (greeter_session), display_server);
1061     if (!display_server_start (display_server))
1062         return FALSE;
1063
1064     return TRUE;
1065 }
1066
1067 gboolean
1068 seat_switch_to_user (Seat *seat, const gchar *username, const gchar *session_name)
1069 {
1070     Session *session;
1071     DisplayServer *display_server;
1072
1073     g_return_val_if_fail (seat != NULL, FALSE);
1074     g_return_val_if_fail (username != NULL, FALSE);
1075
1076     if (!seat->priv->can_switch)
1077         return FALSE;
1078
1079     g_debug ("Switching to user %s", username);
1080
1081     session = find_user_session (seat, username);
1082     if (session)
1083     {
1084         g_debug ("Switching to existing user session %s", username);
1085         seat_set_active_session (seat, session);
1086         return TRUE;
1087     }
1088
1089     session = create_user_session (seat, username);
1090     if (seat->priv->session_to_activate)
1091         g_object_unref (seat->priv->session_to_activate);
1092     seat->priv->session_to_activate = g_object_ref (session);
1093     session_set_pam_service (session, USER_SERVICE);
1094
1095     display_server = create_display_server (seat);
1096     session_set_display_server (session, display_server);
1097     if (!display_server_start (display_server))
1098         return FALSE;
1099
1100     return FALSE;
1101 }
1102
1103 static Session *
1104 find_guest_session (Seat *seat)
1105 {
1106     GList *link;
1107
1108     for (link = seat->priv->sessions; link; link = link->next)
1109     {
1110         Session *session = link->data;
1111         if (!session_get_is_stopping (session) && session_get_is_guest (session))
1112             return session;
1113     }
1114
1115     return NULL;
1116 }
1117
1118 gboolean
1119 seat_switch_to_guest (Seat *seat, const gchar *session_name)
1120 {
1121     Session *session;
1122     DisplayServer *display_server;
1123     GList *link;
1124
1125     g_return_val_if_fail (seat != NULL, FALSE);
1126
1127     if (!seat->priv->can_switch || !seat_get_allow_guest (seat))
1128         return FALSE;
1129
1130     /* Switch to session if one open */
1131     session = find_guest_session (seat);
1132     if (session)
1133     {
1134         g_debug ("Switching to existing guest account %s", session_get_username (session));
1135         seat_set_active_session (seat, session);
1136         return TRUE;
1137     }
1138
1139     display_server = create_display_server (seat);
1140     if (!display_server_start (display_server))
1141         return FALSE;
1142
1143     session = create_guest_session (seat);
1144     if (seat->priv->session_to_activate)
1145         g_object_unref (seat->priv->session_to_activate);
1146     seat->priv->session_to_activate = g_object_ref (session);
1147     session_set_pam_service (session, AUTOLOGIN_SERVICE);
1148     session_set_display_server (session, display_server);
1149
1150     return TRUE;
1151 }
1152
1153 gboolean
1154 seat_lock (Seat *seat, const gchar *username)
1155 {
1156     Greeter *greeter_session;
1157     DisplayServer *display_server;
1158
1159     g_return_val_if_fail (seat != NULL, FALSE);
1160
1161     if (!seat->priv->can_switch)
1162         return FALSE;
1163
1164     g_debug ("Locking seat");
1165
1166     /* Switch to greeter if one open (shouldn't be though) */
1167     greeter_session = find_greeter_session (seat);
1168     if (greeter_session)
1169     {
1170         g_debug ("Switching to existing greeter");
1171         seat_set_active_session (seat, SESSION (greeter_session));
1172         return TRUE;
1173     }
1174
1175     display_server = create_display_server (seat);
1176     if (!display_server_start (display_server))
1177         return FALSE;
1178
1179     greeter_session = create_greeter_session (seat);
1180     if (seat->priv->session_to_activate)
1181         g_object_unref (seat->priv->session_to_activate);
1182     seat->priv->session_to_activate = g_object_ref (greeter_session);
1183     greeter_set_hint (greeter_session, "lock-screen", "true");
1184     if (username)
1185         greeter_set_hint (greeter_session, "select-user", username);
1186     session_set_display_server (SESSION (greeter_session), display_server);
1187
1188     return TRUE;
1189 }
1190
1191 void
1192 seat_stop (Seat *seat)
1193 {
1194     g_return_if_fail (seat != NULL);
1195
1196     if (seat->priv->stopping)
1197         return;
1198
1199     g_debug ("Stopping seat");
1200     seat->priv->stopping = TRUE;
1201     SEAT_GET_CLASS (seat)->stop (seat);
1202 }
1203
1204 gboolean
1205 seat_get_is_stopping (Seat *seat)
1206 {
1207     g_return_val_if_fail (seat != NULL, FALSE);
1208     return seat->priv->stopping;
1209 }
1210
1211 static void
1212 seat_real_setup (Seat *seat)
1213 {
1214 }
1215
1216 static gboolean
1217 seat_real_start (Seat *seat)
1218 {
1219     const gchar *autologin_username;
1220     int autologin_timeout;
1221     gboolean autologin_guest;
1222     gboolean autologin_in_background;
1223     const gchar *user_session;
1224     Session *session = NULL;
1225     DisplayServer *display_server;
1226     User *user;
1227     gchar *sessions_dir;
1228     const gchar *wrapper = NULL;
1229     const gchar *session_name = NULL;
1230
1231     g_debug ("Starting seat");
1232
1233     display_server = create_display_server (seat);
1234
1235     /* Get autologin settings */
1236     autologin_username = seat_get_string_property (seat, "autologin-user");
1237     if (g_strcmp0 (autologin_username, "") == 0)
1238         autologin_username = NULL;
1239     autologin_timeout = seat_get_integer_property (seat, "autologin-user-timeout");
1240     autologin_guest = seat_get_boolean_property (seat, "autologin-guest");
1241     autologin_in_background = seat_get_boolean_property (seat, "autologin-in-background");
1242
1243     /* Autologin if configured */
1244     if (autologin_timeout == 0 || autologin_in_background)
1245     {
1246         if (autologin_guest)
1247         {
1248             session = create_guest_session (seat);
1249             if (seat->priv->session_to_activate)
1250                 g_object_unref (seat->priv->session_to_activate);
1251             seat->priv->session_to_activate = g_object_ref (session);
1252             session_set_pam_service (session, AUTOLOGIN_SERVICE);
1253         }
1254         else if (autologin_username != NULL)
1255         {
1256             session = create_user_session (seat, autologin_username);
1257             if (seat->priv->session_to_activate)
1258                 g_object_unref (seat->priv->session_to_activate);
1259             seat->priv->session_to_activate = g_object_ref (session);
1260             session_set_pam_service (session, AUTOLOGIN_SERVICE);
1261         }
1262
1263         /* Load in background if required */
1264         if (autologin_in_background && session)
1265         {
1266             DisplayServer *background_display_server;
1267
1268             background_display_server = create_display_server (seat);
1269             session_set_display_server (session, background_display_server);
1270             if (!display_server_start (background_display_server))
1271                 return FALSE;
1272
1273             /* Start a greeter as well */
1274             session = NULL;
1275         }
1276     }
1277
1278     /* Fallback to a greeter */
1279     if (!session)
1280     {
1281         Greeter *greeter_session;
1282
1283         greeter_session = create_greeter_session (seat);
1284         if (seat->priv->session_to_activate)
1285             g_object_unref (seat->priv->session_to_activate);
1286         seat->priv->session_to_activate = g_object_ref (greeter_session);
1287         session = SESSION (greeter_session);
1288
1289         if (autologin_timeout)
1290         {
1291             gchar *value;
1292
1293             value = g_strdup_printf ("%d", autologin_timeout);
1294             greeter_set_hint (greeter_session, "autologin-timeout", value);
1295             g_free (value);
1296             if (autologin_username)
1297                 greeter_set_hint (greeter_session, "autologin-user", autologin_username);
1298             if (autologin_guest)
1299                 greeter_set_hint (greeter_session, "autologin-guest", "true");
1300         }
1301     }
1302
1303     /* Fail if can't start a session */
1304     if (!session)
1305     {
1306         seat_stop (seat);
1307         return FALSE;
1308     }
1309
1310     /* Start display server to show session on */
1311     session_set_display_server (session, display_server);
1312     if (!display_server_start (display_server))
1313         return FALSE;
1314
1315     return TRUE;
1316 }
1317
1318 static void
1319 seat_real_set_active_session (Seat *seat, Session *session)
1320 {
1321 }
1322
1323 static Session *
1324 seat_real_get_active_session (Seat *seat)
1325 {
1326     return NULL;
1327 }
1328
1329 static void
1330 seat_real_stop (Seat *seat)
1331 {
1332     GList *list, *link;
1333
1334     check_stopped (seat);
1335     if (seat->priv->stopped)
1336         return;
1337
1338     /* Stop all the display servers and sessions on the seat. Copy the list as
1339      * it might be modified if a display server / session stops during this loop */
1340     list = g_list_copy (seat->priv->display_servers);
1341     for (link = list; link; link = link->next)
1342     {
1343         DisplayServer *display_server = link->data;
1344         if (!display_server_get_is_stopping (display_server))
1345         {
1346             g_debug ("Stopping display server");
1347             display_server_stop (display_server);
1348         }
1349     }
1350     g_list_free (list);
1351     list = g_list_copy (seat->priv->sessions);
1352     for (link = list; link; link = link->next)
1353     {
1354         Session *session = link->data;
1355         if (!session_get_is_stopping (session))
1356         {
1357             g_debug ("Stopping session");
1358             session_stop (session);
1359         }
1360     }
1361     g_list_free (list);
1362 }
1363
1364 static void
1365 seat_init (Seat *seat)
1366 {
1367     seat->priv = G_TYPE_INSTANCE_GET_PRIVATE (seat, SEAT_TYPE, SeatPrivate);
1368     seat->priv->properties = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
1369     seat->priv->share_display_server = TRUE;
1370 }
1371
1372 static void
1373 seat_finalize (GObject *object)
1374 {
1375     Seat *self;
1376     GList *link;
1377
1378     self = SEAT (object);
1379
1380     g_hash_table_unref (self->priv->properties);
1381     for (link = self->priv->display_servers; link; link = link->next)
1382     {
1383         DisplayServer *display_server = link->data;
1384         g_signal_handlers_disconnect_matched (display_server, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, self);
1385     }
1386     g_list_free_full (self->priv->display_servers, g_object_unref);
1387     for (link = self->priv->sessions; link; link = link->next)
1388     {
1389         Session *session = link->data;
1390         g_signal_handlers_disconnect_matched (session, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, self);
1391     }
1392     g_list_free_full (self->priv->sessions, g_object_unref);
1393     if (self->priv->session_to_activate)
1394         g_object_unref (self->priv->session_to_activate);
1395
1396     G_OBJECT_CLASS (seat_parent_class)->finalize (object);
1397 }
1398
1399 static void
1400 seat_class_init (SeatClass *klass)
1401 {
1402     GObjectClass *object_class = G_OBJECT_CLASS (klass);
1403
1404     klass->setup = seat_real_setup;
1405     klass->start = seat_real_start;
1406     klass->set_active_session = seat_real_set_active_session;
1407     klass->get_active_session = seat_real_get_active_session;
1408     klass->run_script = seat_real_run_script;
1409     klass->stop = seat_real_stop;
1410
1411     object_class->finalize = seat_finalize;
1412
1413     g_type_class_add_private (klass, sizeof (SeatPrivate));
1414
1415     signals[SESSION_ADDED] =
1416         g_signal_new ("session-added",
1417                       G_TYPE_FROM_CLASS (klass),
1418                       G_SIGNAL_RUN_LAST,
1419                       G_STRUCT_OFFSET (SeatClass, session_added),
1420                       NULL, NULL,
1421                       g_cclosure_marshal_VOID__OBJECT,
1422                       G_TYPE_NONE, 1, SESSION_TYPE);
1423     signals[SESSION_REMOVED] =
1424         g_signal_new ("session-removed",
1425                       G_TYPE_FROM_CLASS (klass),
1426                       G_SIGNAL_RUN_LAST,
1427                       G_STRUCT_OFFSET (SeatClass, session_removed),
1428                       NULL, NULL,
1429                       g_cclosure_marshal_VOID__OBJECT,
1430                       G_TYPE_NONE, 1, SESSION_TYPE);
1431     signals[STOPPED] =
1432         g_signal_new ("stopped",
1433                       G_TYPE_FROM_CLASS (klass),
1434                       G_SIGNAL_RUN_LAST,
1435                       G_STRUCT_OFFSET (SeatClass, stopped),
1436                       NULL, NULL,
1437                       g_cclosure_marshal_VOID__VOID,
1438                       G_TYPE_NONE, 0);
1439 }