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