src/greeter.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 <config.h>
  13
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <errno.h>
  17 #include <fcntl.h>
  18 #include <gcrypt.h>
  19
  20 #include "greeter.h"
  21 #include "configuration.h"
  22 #include "shared-data-manager.h"
  23
  24 enum {
  25     PROP_0,
  26     PROP_ACTIVE_USERNAME,
  27 };
  28
  29 enum {
  30     CONNECTED,
  31     CREATE_SESSION,
  32     START_SESSION,
  33     LAST_SIGNAL
  34 };
  35 static guint signals[LAST_SIGNAL] = { 0 };
  36
  37 struct GreeterPrivate
  38 {
  39     /* PAM service to authenticate with */
  40     gchar *pam_service;
  41     gchar *autologin_pam_service;
  42
  43     /* Buffer for data read from greeter */
  44     guint8 *read_buffer;
  45     gsize n_read;
  46     gboolean use_secure_memory;
  47
  48     /* Hints for the greeter */
  49     GHashTable *hints;
  50
  51     /* Default session to use */
  52     gchar *default_session;
  53
  54     /* Sequence number of current PAM session */
  55     guint32 authentication_sequence_number;
  56
  57     /* Remote session name */
  58     gchar *remote_session;
  59
  60     /* Currently selected user */
  61     gchar *active_username;
  62
  63     /* PAM session being constructed by the greeter */
  64     Session *authentication_session;
  65
  66     /* TRUE if a the greeter can handle a reset; else we will just kill it instead */
  67     gboolean resettable;
  68
  69     /* TRUE if a user has been authenticated and the session requested to start */
  70     gboolean start_session;
  71
  72     /* TRUE if can log into guest accounts */
  73     gboolean allow_guest;
  74
  75     /* TRUE if logging into guest session */
  76     gboolean guest_account_authenticated;
  77
  78     /* Communication channels to communicate with */
  79     GIOChannel *to_greeter_channel;
  80     GIOChannel *from_greeter_channel;
  81     guint from_greeter_watch;
  82 };
  83
  84 G_DEFINE_TYPE (Greeter, greeter, SESSION_TYPE);
  85
  86 /* Messages from the greeter to the server */
  87 typedef enum
  88 {
  89     GREETER_MESSAGE_CONNECT = 0,
  90     GREETER_MESSAGE_AUTHENTICATE,
  91     GREETER_MESSAGE_AUTHENTICATE_AS_GUEST,
  92     GREETER_MESSAGE_CONTINUE_AUTHENTICATION,
  93     GREETER_MESSAGE_START_SESSION,
  94     GREETER_MESSAGE_CANCEL_AUTHENTICATION,
  95     GREETER_MESSAGE_SET_LANGUAGE,
  96     GREETER_MESSAGE_AUTHENTICATE_REMOTE,
  97     GREETER_MESSAGE_ENSURE_SHARED_DIR,
  98 } GreeterMessage;
  99
 100 /* Messages from the server to the greeter */
 101 typedef enum
 102 {
 103     SERVER_MESSAGE_CONNECTED = 0,
 104     SERVER_MESSAGE_PROMPT_AUTHENTICATION,
 105     SERVER_MESSAGE_END_AUTHENTICATION,
 106     SERVER_MESSAGE_SESSION_RESULT,
 107     SERVER_MESSAGE_SHARED_DIR_RESULT,
 108     SERVER_MESSAGE_IDLE,
 109     SERVER_MESSAGE_RESET,
 110 } ServerMessage;
 111
 112 static gboolean read_cb (GIOChannel *source, GIOCondition condition, gpointer data);
 113
 114 Greeter *
 115 greeter_new (void)
 116 {
 117     return g_object_new (GREETER_TYPE, NULL);
 118 }
 119
 120 void
 121 greeter_set_pam_services (Greeter *greeter, const gchar *pam_service, const gchar *autologin_pam_service)
 122 {
 123     g_free (greeter->priv->pam_service);
 124     greeter->priv->pam_service = g_strdup (pam_service);
 125     g_free (greeter->priv->autologin_pam_service);
 126     greeter->priv->autologin_pam_service = g_strdup (autologin_pam_service);
 127 }
 128
 129 void
 130 greeter_set_allow_guest (Greeter *greeter, gboolean allow_guest)
 131 {
 132     greeter->priv->allow_guest = allow_guest;
 133 }
 134
 135 void
 136 greeter_clear_hints (Greeter *greeter)
 137 {
 138     g_hash_table_remove_all (greeter->priv->hints);
 139 }
 140
 141 void
 142 greeter_set_hint (Greeter *greeter, const gchar *name, const gchar *value)
 143 {
 144     g_hash_table_insert (greeter->priv->hints, g_strdup (name), g_strdup (value));
 145 }
 146
 147 static void *
 148 secure_malloc (Greeter *greeter, size_t n)
 149 {
 150     if (greeter->priv->use_secure_memory)
 151         return gcry_malloc_secure (n);
 152     else
 153         return g_malloc (n);
 154 }
 155
 156 static void *
 157 secure_realloc (Greeter *greeter, void *ptr, size_t n)
 158 {
 159     if (greeter->priv->use_secure_memory)
 160         return gcry_realloc (ptr, n);
 161     else
 162         return g_realloc (ptr, n);
 163 }
 164
 165 static void
 166 secure_free (Greeter *greeter, void *ptr)
 167 {
 168     if (greeter->priv->use_secure_memory)
 169         return gcry_free (ptr);
 170     else
 171         return g_free (ptr);
 172 }
 173
 174 static guint32
 175 int_length (void)
 176 {
 177     return 4;
 178 }
 179
 180 #define HEADER_SIZE (sizeof (guint32) * 2)
 181 #define MAX_MESSAGE_LENGTH 1024
 182
 183 static void
 184 write_message (Greeter *greeter, guint8 *message, gsize message_length)
 185 {
 186     gchar *data;
 187     gsize data_length;
 188     GError *error = NULL;
 189
 190     data = (gchar *) message;
 191     data_length = message_length;
 192     while (data_length > 0)
 193     {
 194         GIOStatus status;
 195         gsize n_written;
 196
 197         status = g_io_channel_write_chars (greeter->priv->to_greeter_channel, data, data_length, &n_written, &error);
 198         if (error)
 199             l_warning (greeter, "Error writing to greeter: %s", error->message);
 200         g_clear_error (&error);
 201         if (status != G_IO_STATUS_NORMAL)
 202             return;
 203         data_length -= n_written;
 204         data += n_written;
 205     }
 206
 207     g_io_channel_flush (greeter->priv->to_greeter_channel, &error);
 208     if (error)
 209         l_warning (greeter, "Failed to flush data to greeter: %s", error->message);
 210     g_clear_error (&error);
 211 }
 212
 213 static void
 214 write_int (guint8 *buffer, gint buffer_length, guint32 value, gsize *offset)
 215 {
 216     if (*offset + 4 >= buffer_length)
 217         return;
 218     buffer[*offset] = value >> 24;
 219     buffer[*offset+1] = (value >> 16) & 0xFF;
 220     buffer[*offset+2] = (value >> 8) & 0xFF;
 221     buffer[*offset+3] = value & 0xFF;
 222     *offset += 4;
 223 }
 224
 225 static void
 226 write_string (guint8 *buffer, gint buffer_length, const gchar *value, gsize *offset)
 227 {
 228     gint length;
 229
 230     if (value)
 231         length = strlen (value);
 232     else
 233         length = 0;
 234     write_int (buffer, buffer_length, length, offset);
 235     if (*offset + length >= buffer_length)
 236         return;
 237     if (length > 0)
 238     {
 239         memcpy (buffer + *offset, value, length);
 240         *offset += length;
 241     }
 242 }
 243
 244 static void
 245 write_header (guint8 *buffer, gint buffer_length, guint32 id, guint32 length, gsize *offset)
 246 {
 247     write_int (buffer, buffer_length, id, offset);
 248     write_int (buffer, buffer_length, length, offset);
 249 }
 250
 251 static guint32
 252 string_length (const gchar *value)
 253 {
 254     if (value == NULL)
 255         return int_length ();
 256     else
 257         return int_length () + strlen (value);
 258 }
 259
 260 static void
 261 handle_connect (Greeter *greeter, const gchar *version, gboolean resettable)
 262 {
 263     guint8 message[MAX_MESSAGE_LENGTH];
 264     gsize offset = 0;
 265     guint32 length;
 266     GHashTableIter iter;
 267     gpointer key, value;
 268
 269     l_debug (greeter, "Greeter connected version=%s resettable=%s", version, resettable ? "true" : "false");
 270
 271     greeter->priv->resettable = resettable;
 272
 273     length = string_length (VERSION);
 274     g_hash_table_iter_init (&iter, greeter->priv->hints);
 275     while (g_hash_table_iter_next (&iter, &key, &value))
 276         length += string_length (key) + string_length (value);
 277
 278     write_header (message, MAX_MESSAGE_LENGTH, SERVER_MESSAGE_CONNECTED, length, &offset);
 279     write_string (message, MAX_MESSAGE_LENGTH, VERSION, &offset);
 280     g_hash_table_iter_init (&iter, greeter->priv->hints);
 281     while (g_hash_table_iter_next (&iter, &key, &value))
 282     {
 283         write_string (message, MAX_MESSAGE_LENGTH, key, &offset);
 284         write_string (message, MAX_MESSAGE_LENGTH, value, &offset);
 285     }
 286     write_message (greeter, message, offset);
 287
 288     g_signal_emit (greeter, signals[CONNECTED], 0);
 289 }
 290
 291 static void
 292 pam_messages_cb (Session *session, Greeter *greeter)
 293 {
 294     int i;
 295     guint32 size;
 296     guint8 message[MAX_MESSAGE_LENGTH];
 297     const struct pam_message *messages;
 298     int messages_length;
 299     gsize offset = 0;
 300     int n_prompts = 0;
 301
 302     messages = session_get_messages (session);
 303     messages_length = session_get_messages_length (session);
 304
 305     /* Respond to d-bus query with messages */
 306     l_debug (greeter, "Prompt greeter with %d message(s)", messages_length);
 307     size = int_length () + string_length (session_get_username (session)) + int_length ();
 308     for (i = 0; i < messages_length; i++)
 309         size += int_length () + string_length (messages[i].msg);
 310
 311     write_header (message, MAX_MESSAGE_LENGTH, SERVER_MESSAGE_PROMPT_AUTHENTICATION, size, &offset);
 312     write_int (message, MAX_MESSAGE_LENGTH, greeter->priv->authentication_sequence_number, &offset);
 313     write_string (message, MAX_MESSAGE_LENGTH, session_get_username (session), &offset);
 314     write_int (message, MAX_MESSAGE_LENGTH, messages_length, &offset);
 315     for (i = 0; i < messages_length; i++)
 316     {
 317         write_int (message, MAX_MESSAGE_LENGTH, messages[i].msg_style, &offset);
 318         write_string (message, MAX_MESSAGE_LENGTH, messages[i].msg, &offset);
 319
 320         if (messages[i].msg_style == PAM_PROMPT_ECHO_OFF || messages[i].msg_style == PAM_PROMPT_ECHO_ON)
 321             n_prompts++;
 322     }
 323     write_message (greeter, message, offset);
 324
 325     /* Continue immediately if nothing to respond with */
 326     // FIXME: Should probably give the greeter a chance to ack the message
 327     if (n_prompts == 0)
 328     {
 329         struct pam_response *response;
 330         response = calloc (messages_length, sizeof (struct pam_response));
 331         session_respond (greeter->priv->authentication_session, response);
 332         free (response);
 333     }
 334 }
 335
 336 static void
 337 send_end_authentication (Greeter *greeter, guint32 sequence_number, const gchar *username, int result)
 338 {
 339     guint8 message[MAX_MESSAGE_LENGTH];
 340     gsize offset = 0;
 341
 342     write_header (message, MAX_MESSAGE_LENGTH, SERVER_MESSAGE_END_AUTHENTICATION, int_length () + string_length (username) + int_length (), &offset);
 343     write_int (message, MAX_MESSAGE_LENGTH, sequence_number, &offset);
 344     write_string (message, MAX_MESSAGE_LENGTH, username, &offset);
 345     write_int (message, MAX_MESSAGE_LENGTH, result, &offset);
 346     write_message (greeter, message, offset);
 347 }
 348
 349 void
 350 greeter_idle (Greeter *greeter)
 351 {
 352     guint8 message[MAX_MESSAGE_LENGTH];
 353     gsize offset = 0;
 354
 355     write_header (message, MAX_MESSAGE_LENGTH, SERVER_MESSAGE_IDLE, 0, &offset);
 356     write_message (greeter, message, offset);
 357 }
 358
 359 void
 360 greeter_reset (Greeter *greeter)
 361 {
 362     guint8 message[MAX_MESSAGE_LENGTH];
 363     gsize offset = 0;
 364     guint32 length = 0;
 365     GHashTableIter iter;
 366     gpointer key, value;
 367
 368     g_hash_table_iter_init (&iter, greeter->priv->hints);
 369     while (g_hash_table_iter_next (&iter, &key, &value))
 370         length += string_length (key) + string_length (value);
 371
 372     write_header (message, MAX_MESSAGE_LENGTH, SERVER_MESSAGE_RESET, length, &offset);
 373     g_hash_table_iter_init (&iter, greeter->priv->hints);
 374     while (g_hash_table_iter_next (&iter, &key, &value))
 375     {
 376         write_string (message, MAX_MESSAGE_LENGTH, key, &offset);
 377         write_string (message, MAX_MESSAGE_LENGTH, value, &offset);
 378     }
 379     write_message (greeter, message, offset);
 380 }
 381
 382 static void
 383 authentication_complete_cb (Session *session, Greeter *greeter)
 384 {
 385     int result;
 386
 387     l_debug (greeter, "Authenticate result for user %s: %s", session_get_username (session), session_get_authentication_result_string (session));
 388
 389     result = session_get_authentication_result (session);
 390     if (session_get_is_authenticated (session))
 391     {
 392         if (session_get_user (session))
 393             l_debug (greeter, "User %s authorized", session_get_username (session));
 394         else
 395         {
 396             l_debug (greeter, "User %s authorized, but no account of that name exists", session_get_username (session));
 397             result = PAM_USER_UNKNOWN;
 398         }
 399     }
 400
 401     send_end_authentication (greeter, greeter->priv->authentication_sequence_number, session_get_username (session), result);
 402 }
 403
 404 static void
 405 reset_session (Greeter *greeter)
 406 {
 407     g_free (greeter->priv->remote_session);
 408     greeter->priv->remote_session = NULL;
 409     if (greeter->priv->authentication_session)
 410     {
 411         g_signal_handlers_disconnect_matched (greeter->priv->authentication_session, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, greeter);
 412         session_stop (greeter->priv->authentication_session);
 413         g_object_unref (greeter->priv->authentication_session);
 414         greeter->priv->authentication_session = NULL;
 415     }
 416
 417     greeter->priv->guest_account_authenticated = FALSE;
 418 }
 419
 420 static void
 421 handle_login (Greeter *greeter, guint32 sequence_number, const gchar *username)
 422 {
 423     const gchar *autologin_username, *service;
 424     gboolean is_interactive;
 425
 426     if (username[0] == '\0')
 427     {
 428         l_debug (greeter, "Greeter start authentication");
 429         username = NULL;
 430     }
 431     else
 432         l_debug (greeter, "Greeter start authentication for %s", username);
 433
 434     reset_session (greeter);
 435
 436     if (greeter->priv->active_username)
 437         g_free (greeter->priv->active_username);
 438     greeter->priv->active_username = g_strdup (username);
 439     g_object_notify (G_OBJECT (greeter), "active-username");
 440
 441     greeter->priv->authentication_sequence_number = sequence_number;
 442     g_signal_emit (greeter, signals[CREATE_SESSION], 0, &greeter->priv->authentication_session);
 443     if (!greeter->priv->authentication_session)
 444     {
 445         send_end_authentication (greeter, sequence_number, "", PAM_USER_UNKNOWN);
 446         return;
 447     }
 448
 449     g_signal_connect (G_OBJECT (greeter->priv->authentication_session), "got-messages", G_CALLBACK (pam_messages_cb), greeter);
 450     g_signal_connect (G_OBJECT (greeter->priv->authentication_session), "authentication-complete", G_CALLBACK (authentication_complete_cb), greeter);
 451
 452     /* Use non-interactive service for autologin user */
 453     autologin_username = g_hash_table_lookup (greeter->priv->hints, "autologin-user");
 454     if (autologin_username != NULL && g_strcmp0 (username, autologin_username) == 0)
 455     {
 456         service = greeter->priv->autologin_pam_service;
 457         is_interactive = FALSE;
 458     }
 459     else
 460     {
 461         service = greeter->priv->pam_service;
 462         is_interactive = TRUE;
 463     }
 464
 465     /* Run the session process */
 466     session_set_pam_service (greeter->priv->authentication_session, service);
 467     session_set_username (greeter->priv->authentication_session, username);
 468     session_set_do_authenticate (greeter->priv->authentication_session, TRUE);
 469     session_set_is_interactive (greeter->priv->authentication_session, is_interactive);
 470     session_start (greeter->priv->authentication_session);
 471 }
 472
 473 static void
 474 handle_login_as_guest (Greeter *greeter, guint32 sequence_number)
 475 {
 476     l_debug (greeter, "Greeter start authentication for guest account");
 477
 478     reset_session (greeter);
 479
 480     if (!greeter->priv->allow_guest)
 481     {
 482         l_debug (greeter, "Guest account is disabled");
 483         send_end_authentication (greeter, sequence_number, "", PAM_USER_UNKNOWN);
 484         return;
 485     }
 486
 487     greeter->priv->guest_account_authenticated = TRUE;
 488     send_end_authentication (greeter, sequence_number, "", PAM_SUCCESS);
 489 }
 490
 491 static gchar *
 492 get_remote_session_service (const gchar *session_name)
 493 {
 494     GKeyFile *session_desktop_file;
 495     gboolean result;
 496     const gchar *c;
 497     gchar *remote_sessions_dir, *filename, *path, *service = NULL;
 498     GError *error = NULL;
 499
 500     /* Validate session name doesn't contain directory separators */
 501     for (c = session_name; *c; c++)
 502     {
 503         if (*c == '/')
 504             return NULL;
 505     }
 506
 507     /* Load the session file */
 508     session_desktop_file = g_key_file_new ();
 509     filename = g_strdup_printf ("%s.desktop", session_name);
 510     remote_sessions_dir = config_get_string (config_get_instance (), "LightDM", "remote-sessions-directory");
 511     path = g_build_filename (remote_sessions_dir, filename, NULL);
 512     g_free (remote_sessions_dir);
 513     g_free (filename);
 514     result = g_key_file_load_from_file (session_desktop_file, path, G_KEY_FILE_NONE, &error);
 515     if (error)
 516         g_debug ("Failed to load session file %s: %s", path, error->message);
 517     g_free (path);
 518     g_clear_error (&error);
 519     if (result)
 520         service = g_key_file_get_string (session_desktop_file, G_KEY_FILE_DESKTOP_GROUP, "X-LightDM-PAM-Service", NULL);
 521     g_key_file_free (session_desktop_file);
 522
 523     return service;
 524 }
 525
 526 static void
 527 handle_login_remote (Greeter *greeter, const gchar *session_name, const gchar *username, guint32 sequence_number)
 528 {
 529     gchar *service;
 530
 531     if (username[0] == '\0')
 532     {
 533         l_debug (greeter, "Greeter start authentication for remote session %s", session_name);
 534         username = NULL;
 535     }
 536     else
 537         l_debug (greeter, "Greeter start authentication for remote session %s as user %s", session_name, username);
 538
 539     reset_session (greeter);
 540
 541     service = get_remote_session_service (session_name);
 542     if (!service)
 543     {
 544         send_end_authentication (greeter, sequence_number, "", PAM_SYSTEM_ERR);
 545         return;
 546     }
 547
 548     greeter->priv->authentication_sequence_number = sequence_number;
 549     greeter->priv->remote_session = g_strdup (session_name);
 550     g_signal_emit (greeter, signals[CREATE_SESSION], 0, &greeter->priv->authentication_session);
 551     if (greeter->priv->authentication_session)
 552     {
 553         g_signal_connect (G_OBJECT (greeter->priv->authentication_session), "got-messages", G_CALLBACK (pam_messages_cb), greeter);
 554         g_signal_connect (G_OBJECT (greeter->priv->authentication_session), "authentication-complete", G_CALLBACK (authentication_complete_cb), greeter);
 555
 556         /* Run the session process */
 557         session_set_pam_service (greeter->priv->authentication_session, service);
 558         session_set_username (greeter->priv->authentication_session, username);
 559         session_set_do_authenticate (greeter->priv->authentication_session, TRUE);
 560         session_set_is_interactive (greeter->priv->authentication_session, TRUE);
 561         session_set_is_guest (greeter->priv->authentication_session, TRUE);
 562         session_start (greeter->priv->authentication_session);
 563     }
 564
 565     g_free (service);
 566
 567     if (!greeter->priv->authentication_session)
 568     {
 569         send_end_authentication (greeter, sequence_number, "", PAM_USER_UNKNOWN);
 570         return;
 571     }
 572 }
 573
 574 static void
 575 handle_continue_authentication (Greeter *greeter, gchar **secrets)
 576 {
 577     int messages_length;
 578     const struct pam_message *messages;
 579     struct pam_response *response;
 580     int i, j, n_prompts = 0;
 581
 582     /* Not in authentication */
 583     if (greeter->priv->authentication_session == NULL)
 584         return;
 585
 586     messages_length = session_get_messages_length (greeter->priv->authentication_session);
 587     messages = session_get_messages (greeter->priv->authentication_session);
 588
 589     /* Check correct number of responses */
 590     for (i = 0; i < messages_length; i++)
 591     {
 592         int msg_style = messages[i].msg_style;
 593         if (msg_style == PAM_PROMPT_ECHO_OFF || msg_style == PAM_PROMPT_ECHO_ON)
 594             n_prompts++;
 595     }
 596     if (g_strv_length (secrets) != n_prompts)
 597     {
 598         session_respond_error (greeter->priv->authentication_session, PAM_CONV_ERR);
 599         return;
 600     }
 601
 602     l_debug (greeter, "Continue authentication");
 603
 604     /* Build response */
 605     response = calloc (messages_length, sizeof (struct pam_response));
 606     for (i = 0, j = 0; i < messages_length; i++)
 607     {
 608         int msg_style = messages[i].msg_style;
 609         if (msg_style == PAM_PROMPT_ECHO_OFF || msg_style == PAM_PROMPT_ECHO_ON)
 610         {
 611             size_t secret_length = strlen (secrets[j]) + 1;
 612             response[i].resp = secure_malloc (greeter, secret_length);
 613             memcpy (response[i].resp, secrets[j], secret_length); // FIXME: Need to convert from UTF-8
 614             j++;
 615         }
 616     }
 617
 618     session_respond (greeter->priv->authentication_session, response);
 619
 620     for (i = 0; i < messages_length; i++)
 621         secure_free (greeter, response[i].resp);
 622     free (response);
 623 }
 624
 625 static void
 626 handle_cancel_authentication (Greeter *greeter)
 627 {
 628     /* Not in authentication */
 629     if (greeter->priv->authentication_session == NULL)
 630         return;
 631
 632     l_debug (greeter, "Cancel authentication");
 633     reset_session (greeter);
 634 }
 635
 636 static void
 637 handle_start_session (Greeter *greeter, const gchar *session)
 638 {
 639     gboolean result;
 640     guint8 message[MAX_MESSAGE_LENGTH];
 641     gsize offset = 0;
 642     SessionType session_type = SESSION_TYPE_LOCAL;
 643
 644     if (strcmp (session, "") == 0)
 645         session = NULL;
 646
 647     /* Use session type chosen in remote session */
 648     if (greeter->priv->remote_session)
 649     {
 650         session_type = SESSION_TYPE_REMOTE;
 651         session = greeter->priv->remote_session;
 652     }
 653
 654     if (greeter->priv->guest_account_authenticated || session_get_is_authenticated (greeter->priv->authentication_session))
 655     {
 656         if (session)
 657             l_debug (greeter, "Greeter requests session %s", session);
 658         else
 659             l_debug (greeter, "Greeter requests default session");
 660         greeter->priv->start_session = TRUE;
 661         g_signal_emit (greeter, signals[START_SESSION], 0, session_type, session, &result);
 662     }
 663     else
 664     {
 665         l_debug (greeter, "Ignoring start session request, user is not authorized");
 666         result = FALSE;
 667     }
 668
 669     write_header (message, MAX_MESSAGE_LENGTH, SERVER_MESSAGE_SESSION_RESULT, int_length (), &offset);
 670     write_int (message, MAX_MESSAGE_LENGTH, result ? 0 : 1, &offset);
 671     write_message (greeter, message, offset);
 672 }
 673
 674 static void
 675 handle_set_language (Greeter *greeter, const gchar *language)
 676 {
 677     User *user;
 678
 679     if (!greeter->priv->guest_account_authenticated && !session_get_is_authenticated (greeter->priv->authentication_session))
 680     {
 681         l_debug (greeter, "Ignoring set language request, user is not authorized");
 682         return;
 683     }
 684
 685     // FIXME: Could use this
 686     if (greeter->priv->guest_account_authenticated)
 687     {
 688         l_debug (greeter, "Ignoring set language request for guest user");
 689         return;
 690     }
 691
 692     l_debug (greeter, "Greeter sets language %s", language);
 693     user = session_get_user (greeter->priv->authentication_session);
 694     user_set_language (user, language);
 695 }
 696
 697 static void
 698 handle_ensure_shared_dir (Greeter *greeter, const gchar *username)
 699 {
 700     gchar *dir;
 701     guint8 message[MAX_MESSAGE_LENGTH];
 702     gsize offset = 0;
 703
 704     l_debug (greeter, "Greeter requests data directory for user %s", username);
 705
 706     dir = shared_data_manager_ensure_user_dir (shared_data_manager_get_instance (), username);
 707
 708     write_header (message, MAX_MESSAGE_LENGTH, SERVER_MESSAGE_SHARED_DIR_RESULT, string_length (dir), &offset);
 709     write_string (message, MAX_MESSAGE_LENGTH, dir, &offset);
 710     write_message (greeter, message, offset);
 711
 712     g_free (dir);
 713 }
 714
 715 static guint32
 716 read_int (Greeter *greeter, gsize *offset)
 717 {
 718     guint32 value;
 719     guint8 *buffer;
 720     if (greeter->priv->n_read - *offset < sizeof (guint32))
 721     {
 722         l_warning (greeter, "Not enough space for int, need %zu, got %zu", sizeof (guint32), greeter->priv->n_read - *offset);
 723         return 0;
 724     }
 725     buffer = greeter->priv->read_buffer + *offset;
 726     value = buffer[0] << 24 | buffer[1] << 16 | buffer[2] << 8 | buffer[3];
 727     *offset += int_length ();
 728     return value;
 729 }
 730
 731 static int
 732 get_message_length (Greeter *greeter)
 733 {
 734     gsize offset;
 735     int payload_length;
 736
 737     offset = int_length ();
 738     payload_length = read_int (greeter, &offset);
 739
 740     if (HEADER_SIZE + payload_length < HEADER_SIZE)
 741     {
 742         l_warning (greeter, "Payload length of %u octets too long", payload_length);
 743         return HEADER_SIZE;
 744     }
 745
 746     return HEADER_SIZE + payload_length;
 747 }
 748
 749 static gchar *
 750 read_string_full (Greeter *greeter, gsize *offset, void* (*alloc_fn)(size_t n))
 751 {
 752     guint32 length;
 753     gchar *value;
 754
 755     length = read_int (greeter, offset);
 756     if (greeter->priv->n_read - *offset < length)
 757     {
 758         l_warning (greeter, "Not enough space for string, need %u, got %zu", length, greeter->priv->n_read - *offset);
 759         return g_strdup ("");
 760     }
 761
 762     value = (*alloc_fn) (sizeof (gchar) * (length + 1));
 763     memcpy (value, greeter->priv->read_buffer + *offset, length);
 764     value[length] = '\0';
 765     *offset += length;
 766
 767     return value;
 768 }
 769
 770 static gchar *
 771 read_string (Greeter *greeter, gsize *offset)
 772 {
 773     return read_string_full (greeter, offset, g_malloc);
 774 }
 775
 776 static gchar *
 777 read_secret (Greeter *greeter, gsize *offset)
 778 {
 779     if (greeter->priv->use_secure_memory)
 780         return read_string_full (greeter, offset, gcry_malloc_secure);
 781     else
 782         return read_string_full (greeter, offset, g_malloc);
 783 }
 784
 785 static gboolean
 786 read_cb (GIOChannel *source, GIOCondition condition, gpointer data)
 787 {
 788     Greeter *greeter = data;
 789     gsize n_to_read, n_read, offset;
 790     GIOStatus status;
 791     int id, length, i;
 792     guint32 sequence_number, n_secrets, max_secrets;
 793     gchar *version, *username, *session_name, *language;
 794     gchar **secrets;
 795     gboolean resettable = FALSE;
 796     GError *error = NULL;
 797
 798     if (condition == G_IO_HUP)
 799     {
 800         l_debug (greeter, "Greeter closed communication channel");
 801         greeter->priv->from_greeter_watch = 0;
 802         return FALSE;
 803     }
 804
 805     n_to_read = HEADER_SIZE;
 806     if (greeter->priv->n_read >= HEADER_SIZE)
 807     {
 808         n_to_read = get_message_length (greeter);
 809         if (n_to_read <= HEADER_SIZE)
 810         {
 811             greeter->priv->from_greeter_watch = 0;
 812             return FALSE;
 813         }
 814     }
 815
 816     status = g_io_channel_read_chars (greeter->priv->from_greeter_channel,
 817                                       (gchar *) greeter->priv->read_buffer + greeter->priv->n_read,
 818                                       n_to_read - greeter->priv->n_read,
 819                                       &n_read,
 820                                       &error);
 821     if (error)
 822         l_warning (greeter, "Error reading from greeter: %s", error->message);
 823     g_clear_error (&error);
 824     if (status != G_IO_STATUS_NORMAL)
 825         return TRUE;
 826
 827     greeter->priv->n_read += n_read;
 828     if (greeter->priv->n_read != n_to_read)
 829         return TRUE;
 830
 831     /* If have header, rerun for content */
 832     if (greeter->priv->n_read == HEADER_SIZE)
 833     {
 834         n_to_read = get_message_length (greeter);
 835         if (n_to_read > HEADER_SIZE)
 836         {
 837             greeter->priv->read_buffer = secure_realloc (greeter, greeter->priv->read_buffer, n_to_read);
 838             read_cb (source, condition, greeter);
 839             return TRUE;
 840         }
 841     }
 842
 843     offset = 0;
 844     id = read_int (greeter, &offset);
 845     length = HEADER_SIZE + read_int (greeter, &offset);
 846     switch (id)
 847     {
 848     case GREETER_MESSAGE_CONNECT:
 849         version = read_string (greeter, &offset);
 850         if (offset < length)
 851             resettable = read_int (greeter, &offset) != 0;
 852         handle_connect (greeter, version, resettable);
 853         g_free (version);
 854         break;
 855     case GREETER_MESSAGE_AUTHENTICATE:
 856         sequence_number = read_int (greeter, &offset);
 857         username = read_string (greeter, &offset);
 858         handle_login (greeter, sequence_number, username);
 859         g_free (username);
 860         break;
 861     case GREETER_MESSAGE_AUTHENTICATE_AS_GUEST:
 862         sequence_number = read_int (greeter, &offset);
 863         handle_login_as_guest (greeter, sequence_number);
 864         break;
 865     case GREETER_MESSAGE_AUTHENTICATE_REMOTE:
 866         sequence_number = read_int (greeter, &offset);
 867         session_name = read_string (greeter, &offset);
 868         username = read_string (greeter, &offset);
 869         handle_login_remote (greeter, session_name, username, sequence_number);
 870         break;
 871     case GREETER_MESSAGE_CONTINUE_AUTHENTICATION:
 872         n_secrets = read_int (greeter, &offset);
 873         max_secrets = (G_MAXUINT32 - 1) / sizeof (gchar *);
 874         if (n_secrets > max_secrets)
 875         {
 876             l_warning (greeter, "Array length of %u elements too long", n_secrets);
 877             greeter->priv->from_greeter_watch = 0;
 878             return FALSE;
 879         }
 880         secrets = g_malloc (sizeof (gchar *) * (n_secrets + 1));
 881         for (i = 0; i < n_secrets; i++)
 882             secrets[i] = read_secret (greeter, &offset);
 883         secrets[i] = NULL;
 884         handle_continue_authentication (greeter, secrets);
 885         for (i = 0; i < n_secrets; i++)
 886             secure_free (greeter, secrets[i]);
 887         g_free (secrets);
 888         break;
 889     case GREETER_MESSAGE_CANCEL_AUTHENTICATION:
 890         handle_cancel_authentication (greeter);
 891         break;
 892     case GREETER_MESSAGE_START_SESSION:
 893         session_name = read_string (greeter, &offset);
 894         handle_start_session (greeter, session_name);
 895         g_free (session_name);
 896         break;
 897     case GREETER_MESSAGE_SET_LANGUAGE:
 898         language = read_string (greeter, &offset);
 899         handle_set_language (greeter, language);
 900         g_free (language);
 901         break;
 902     case GREETER_MESSAGE_ENSURE_SHARED_DIR:
 903         username = read_string (greeter, &offset);
 904         handle_ensure_shared_dir (greeter, username);
 905         g_free (username);
 906         break;
 907     default:
 908         l_warning (greeter, "Unknown message from greeter: %d", id);
 909         break;
 910     }
 911
 912     greeter->priv->n_read = 0;
 913
 914     return TRUE;
 915 }
 916
 917 gboolean
 918 greeter_get_guest_authenticated (Greeter *greeter)
 919 {
 920     g_return_val_if_fail (greeter != NULL, FALSE);
 921     return greeter->priv->guest_account_authenticated;
 922 }
 923
 924 Session *
 925 greeter_get_authentication_session (Greeter *greeter)
 926 {
 927     g_return_val_if_fail (greeter != NULL, NULL);
 928     return greeter->priv->authentication_session;
 929 }
 930
 931 gboolean
 932 greeter_get_resettable (Greeter *greeter)
 933 {
 934     g_return_val_if_fail (greeter != NULL, FALSE);
 935     return greeter->priv->resettable;
 936 }
 937
 938 gboolean
 939 greeter_get_start_session (Greeter *greeter)
 940 {
 941     g_return_val_if_fail (greeter != NULL, FALSE);
 942     return greeter->priv->start_session;
 943 }
 944
 945 const gchar *
 946 greeter_get_active_username (Greeter *greeter)
 947 {
 948     g_return_val_if_fail (greeter != NULL, NULL);
 949     return greeter->priv->active_username;
 950 }
 951
 952 static gboolean
 953 greeter_start (Session *session)
 954 {
 955     Greeter *greeter = GREETER (session);
 956     int to_greeter_pipe[2], from_greeter_pipe[2];
 957     gboolean result = FALSE;
 958     gchar *value;
 959
 960     /* Create a pipe to talk with the greeter */
 961     if (pipe (to_greeter_pipe) != 0 || pipe (from_greeter_pipe) != 0)
 962     {
 963         g_warning ("Failed to create pipes: %s", strerror (errno));
 964         return FALSE;
 965     }
 966     greeter->priv->to_greeter_channel = g_io_channel_unix_new (to_greeter_pipe[1]);
 967     g_io_channel_set_encoding (greeter->priv->to_greeter_channel, NULL, NULL);
 968     greeter->priv->from_greeter_channel = g_io_channel_unix_new (from_greeter_pipe[0]);
 969     g_io_channel_set_encoding (greeter->priv->from_greeter_channel, NULL, NULL);
 970     g_io_channel_set_buffered (greeter->priv->from_greeter_channel, FALSE);
 971     greeter->priv->from_greeter_watch = g_io_add_watch (greeter->priv->from_greeter_channel, G_IO_IN | G_IO_HUP, read_cb, greeter);
 972
 973     /* Let the greeter session know how to communicate with the daemon */
 974     value = g_strdup_printf ("%d", from_greeter_pipe[1]);
 975     session_set_env (SESSION (greeter), "LIGHTDM_TO_SERVER_FD", value);
 976     g_free (value);
 977     value = g_strdup_printf ("%d", to_greeter_pipe[0]);
 978     session_set_env (SESSION (greeter), "LIGHTDM_FROM_SERVER_FD", value);
 979     g_free (value);
 980
 981     /* Don't allow the daemon end of the pipes to be accessed in child processes */
 982     fcntl (to_greeter_pipe[1], F_SETFD, FD_CLOEXEC);
 983     fcntl (from_greeter_pipe[0], F_SETFD, FD_CLOEXEC);
 984
 985     result = SESSION_CLASS (greeter_parent_class)->start (session);
 986
 987     /* Close the session ends of the pipe */
 988     close (to_greeter_pipe[0]);
 989     close (from_greeter_pipe[1]);
 990
 991     return result;
 992 }
 993
 994 static Session *
 995 greeter_real_create_session (Greeter *greeter)
 996 {
 997     return NULL;
 998 }
 999
1000 static gboolean
1001 greeter_real_start_session (Greeter *greeter, SessionType type, const gchar *session)
1002 {
1003     return FALSE;
1004 }
1005
1006 static void
1007 greeter_stop (Session *session)
1008 {
1009     Greeter *greeter = GREETER (session);
1010
1011     /* Stop any events occurring after we've stopped */
1012     if (greeter->priv->authentication_session)
1013         g_signal_handlers_disconnect_matched (greeter->priv->authentication_session, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, greeter);
1014
1015     SESSION_CLASS (greeter_parent_class)->stop (session);
1016 }
1017
1018 static void
1019 greeter_init (Greeter *greeter)
1020 {
1021     greeter->priv = G_TYPE_INSTANCE_GET_PRIVATE (greeter, GREETER_TYPE, GreeterPrivate);
1022     greeter->priv->read_buffer = secure_malloc (greeter, HEADER_SIZE);
1023     greeter->priv->hints = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
1024     greeter->priv->use_secure_memory = config_get_boolean (config_get_instance (), "LightDM", "lock-memory");
1025 }
1026
1027 static void
1028 greeter_finalize (GObject *object)
1029 {
1030     Greeter *self;
1031
1032     self = GREETER (object);
1033
1034     g_free (self->priv->pam_service);
1035     g_free (self->priv->autologin_pam_service);
1036     secure_free (self, self->priv->read_buffer);
1037     g_hash_table_unref (self->priv->hints);
1038     g_free (self->priv->remote_session);
1039     g_free (self->priv->active_username);
1040     if (self->priv->authentication_session)
1041     {
1042         g_signal_handlers_disconnect_matched (self->priv->authentication_session, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, self);
1043         g_object_unref (self->priv->authentication_session);
1044     }
1045     if (self->priv->to_greeter_channel)
1046         g_io_channel_unref (self->priv->to_greeter_channel);
1047     if (self->priv->from_greeter_channel)
1048         g_io_channel_unref (self->priv->from_greeter_channel);
1049     if (self->priv->from_greeter_watch)
1050         g_source_remove (self->priv->from_greeter_watch);
1051
1052     G_OBJECT_CLASS (greeter_parent_class)->finalize (object);
1053 }
1054
1055 static void
1056 greeter_set_property (GObject      *object,
1057                       guint         prop_id,
1058                       const GValue *value,
1059                       GParamSpec   *pspec)
1060 {
1061     G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1062 }
1063
1064 static void
1065 greeter_get_property (GObject    *object,
1066                       guint       prop_id,
1067                       GValue     *value,
1068                       GParamSpec *pspec)
1069 {
1070     Greeter *greeter = GREETER (object);
1071
1072     switch (prop_id) {
1073     case PROP_ACTIVE_USERNAME:
1074         g_value_set_string (value, greeter_get_active_username (greeter));
1075         break;
1076     default:
1077         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1078         break;
1079     }
1080 }
1081
1082 static void
1083 greeter_class_init (GreeterClass *klass)
1084 {
1085     SessionClass *session_class = SESSION_CLASS (klass);
1086     GObjectClass *object_class = G_OBJECT_CLASS (klass);
1087
1088     klass->create_session = greeter_real_create_session;
1089     klass->start_session = greeter_real_start_session;
1090     session_class->start = greeter_start;
1091     session_class->stop = greeter_stop;
1092     object_class->finalize = greeter_finalize;
1093     object_class->get_property = greeter_get_property;
1094     object_class->set_property = greeter_set_property;
1095
1096     signals[CONNECTED] =
1097         g_signal_new ("connected",
1098                       G_TYPE_FROM_CLASS (klass),
1099                       G_SIGNAL_RUN_LAST,
1100                       G_STRUCT_OFFSET (GreeterClass, connected),
1101                       NULL, NULL,
1102                       NULL,
1103                       G_TYPE_NONE, 0);
1104
1105     signals[CREATE_SESSION] =
1106         g_signal_new ("create-session",
1107                       G_TYPE_FROM_CLASS (klass),
1108                       G_SIGNAL_RUN_LAST,
1109                       G_STRUCT_OFFSET (GreeterClass, create_session),
1110                       g_signal_accumulator_first_wins,
1111                       NULL,
1112                       NULL,
1113                       SESSION_TYPE, 0);
1114
1115     signals[START_SESSION] =
1116         g_signal_new ("start-session",
1117                       G_TYPE_FROM_CLASS (klass),
1118                       G_SIGNAL_RUN_LAST,
1119                       G_STRUCT_OFFSET (GreeterClass, start_session),
1120                       g_signal_accumulator_true_handled,
1121                       NULL,
1122                       NULL,
1123                       G_TYPE_BOOLEAN, 2, G_TYPE_INT, G_TYPE_STRING);
1124
1125     g_object_class_install_property (object_class,
1126                                      PROP_ACTIVE_USERNAME,
1127                                      g_param_spec_string ("active-username",
1128                                                           "active-username",
1129                                                           "Active username",
1130                                                           NULL,
1131                                                           G_PARAM_READABLE));
1132
1133     g_type_class_add_private (klass, sizeof (GreeterPrivate));
1134 }