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