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