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