src/session-child.c

   1 #include <config.h>
   2
   3 #include <stdlib.h>
   4 #include <stdio.h>
   5 #include <unistd.h>
   6 #include <string.h>
   7 #include <errno.h>
   8 #include <sys/types.h>
   9 #include <sys/stat.h>
  10 #include <sys/wait.h>
  11 #include <fcntl.h>
  12 #include <pwd.h>
  13 #include <grp.h>
  14 #include <glib.h>
  15 #include <security/pam_appl.h>
  16 #include <utmpx.h>
  17 #include <sys/mman.h>
  18
  19 #include "configuration.h"
  20 #include "session-child.h"
  21 #include "session.h"
  22 #include "console-kit.h"
  23 #include "login1.h"
  24 #include "privileges.h"
  25 #include "x-authority.h"
  26 #include "configuration.h"
  27
  28 /* Child process being run */
  29 static GPid child_pid = 0;
  30
  31 /* Pipe to communicate with daemon */
  32 static int from_daemon_output = 0;
  33 static int to_daemon_input = 0;
  34
  35 static gboolean is_interactive;
  36 static gboolean do_authenticate;
  37 static gboolean authentication_complete = FALSE;
  38 static pam_handle_t *pam_handle;
  39
  40 /* Maximum length of a string to pass between daemon and session */
  41 #define MAX_STRING_LENGTH 65535
  42
  43 static void
  44 write_data (const void *buf, size_t count)
  45 {
  46     if (write (to_daemon_input, buf, count) != count)
  47         g_printerr ("Error writing to daemon: %s\n", strerror (errno));
  48 }
  49
  50 static void
  51 write_string (const char *value)
  52 {
  53     int length;
  54
  55     length = value ? strlen (value) : -1;
  56     write_data (&length, sizeof (length));
  57     if (value)
  58         write_data (value, sizeof (char) * length);
  59 }
  60
  61 static ssize_t
  62 read_data (void *buf, size_t count)
  63 {
  64     ssize_t n_read;
  65
  66     n_read = read (from_daemon_output, buf, count);
  67     if (n_read < 0)
  68         g_printerr ("Error reading from daemon: %s\n", strerror (errno));
  69
  70     return n_read;
  71 }
  72
  73 static gchar *
  74 read_string_full (void* (*alloc_fn)(size_t n))
  75 {
  76     int length;
  77     char *value;
  78
  79     if (read_data (&length, sizeof (length)) <= 0)
  80         return NULL;
  81     if (length < 0)
  82         return NULL;
  83     if (length > MAX_STRING_LENGTH)
  84     {
  85         g_printerr ("Invalid string length %d from daemon\n", length);
  86         return NULL;
  87     }
  88
  89     value = (*alloc_fn) (sizeof (char) * (length + 1));
  90     read_data (value, length);
  91     value[length] = '\0';
  92
  93     return value;
  94 }
  95
  96 static gchar *
  97 read_string (void)
  98 {
  99     return read_string_full (g_malloc);
 100 }
 101
 102 static int
 103 pam_conv_cb (int msg_length, const struct pam_message **msg, struct pam_response **resp, void *app_data)
 104 {
 105     int i, error;
 106     gboolean auth_complete = FALSE;
 107     struct pam_response *response;
 108     gchar *username = NULL;
 109
 110     /* FIXME: We don't support communication after pam_authenticate completes */
 111     if (authentication_complete)
 112         return PAM_SUCCESS;
 113
 114     /* Cancel authentication if requiring input */
 115     if (!is_interactive)
 116     {
 117         for (i = 0; i < msg_length; i++)
 118         {
 119             if (msg[i]->msg_style == PAM_PROMPT_ECHO_ON || msg[i]->msg_style == PAM_PROMPT_ECHO_OFF)
 120             {
 121                 g_printerr ("Stopping PAM conversation, interaction requested but not supported\n");
 122                 return PAM_CONV_ERR;
 123             }
 124         }
 125
 126         /* Ignore informational messages */
 127         return PAM_SUCCESS;
 128     }
 129
 130     /* Check if we changed user */
 131     pam_get_item (pam_handle, PAM_USER, (const void **) &username);
 132
 133     /* Notify the daemon */
 134     write_string (username);
 135     write_data (&auth_complete, sizeof (auth_complete));
 136     write_data (&msg_length, sizeof (msg_length));
 137     for (i = 0; i < msg_length; i++)
 138     {
 139         const struct pam_message *m = msg[i];
 140         write_data (&m->msg_style, sizeof (m->msg_style));
 141         write_string (m->msg);
 142     }
 143
 144     /* Get response */
 145     read_data (&error, sizeof (error));
 146     if (error != PAM_SUCCESS)
 147         return error;
 148     response = calloc (msg_length, sizeof (struct pam_response));
 149     for (i = 0; i < msg_length; i++)
 150     {
 151         struct pam_response *r = &response[i];
 152         // callers of this function inside pam will expect to be able to call
 153         // free() on the strings we give back.  So alloc with malloc.
 154         r->resp = read_string_full (malloc);
 155         read_data (&r->resp_retcode, sizeof (r->resp_retcode));
 156     }
 157
 158     *resp = response;
 159     return PAM_SUCCESS;
 160 }
 161
 162 static void
 163 signal_cb (int signum)
 164 {
 165     /* Pass on signal to child, otherwise just quit */
 166     if (child_pid > 0)
 167         kill (child_pid, signum);
 168     else
 169         exit (EXIT_SUCCESS);
 170 }
 171
 172 static XAuthority *
 173 read_xauth (void)
 174 {
 175     gchar *x_authority_name;
 176     guint16 x_authority_family;
 177     guint8 *x_authority_address;
 178     gsize x_authority_address_length;
 179     gchar *x_authority_number;
 180     guint8 *x_authority_data;
 181     gsize x_authority_data_length;
 182
 183     x_authority_name = read_string ();
 184     if (!x_authority_name)
 185         return NULL;
 186
 187     read_data (&x_authority_family, sizeof (x_authority_family));
 188     read_data (&x_authority_address_length, sizeof (x_authority_address_length));
 189     x_authority_address = g_malloc (x_authority_address_length);
 190     read_data (x_authority_address, x_authority_address_length);
 191     x_authority_number = read_string ();
 192     read_data (&x_authority_data_length, sizeof (x_authority_data_length));
 193     x_authority_data = g_malloc (x_authority_data_length);
 194     read_data (x_authority_data, x_authority_data_length);
 195
 196     return x_authority_new (x_authority_family, x_authority_address, x_authority_address_length, x_authority_number, x_authority_name, x_authority_data, x_authority_data_length);
 197 }
 198
 199 int
 200 session_child_run (int argc, char **argv)
 201 {
 202     struct pam_conv conversation = { pam_conv_cb, NULL };
 203     int i, version, fd, result;
 204     gboolean auth_complete = TRUE;
 205     User *user = NULL;
 206     gchar *log_filename, *log_backup_filename = NULL;
 207     gsize env_length;
 208     gsize command_argc;
 209     gchar **command_argv;
 210     GVariantBuilder ck_parameters;
 211     int return_code;
 212     int authentication_result;
 213     gchar *authentication_result_string;
 214     gchar *service;
 215     gchar *username;
 216     gchar *tty;
 217     gchar *remote_host_name;
 218     gchar *xdisplay;
 219     XAuthority *x_authority = NULL;
 220     gchar *x_authority_filename;
 221     GDBusConnection *bus;
 222     gchar *console_kit_cookie = NULL;
 223     gchar *login1_session = NULL;
 224
 225     const gchar *path;
 226     GError *error = NULL;
 227     const gchar *locale_value;
 228     gchar *locale_var;
 229     static const gchar * const locale_var_names[] = {
 230         "LC_COLLATE",
 231         "LC_CTYPE",
 232         "LC_MONETARY",
 233         "LC_NUMERIC",
 234         "LC_TIME",
 235         "LC_MESSAGES",
 236         "LC_ALL",
 237         "LANG",
 238         NULL
 239     };
 240
 241 #if !defined(GLIB_VERSION_2_36)
 242     g_type_init ();
 243 #endif
 244
 245     if (config_get_boolean (config_get_instance (), "LightDM", "lock-memory"))
 246     {
 247         /* Protect memory from being paged to disk, as we deal with passwords */
 248         mlockall (MCL_CURRENT | MCL_FUTURE);
 249     }
 250
 251     /* Make input non-blocking */
 252     fd = open ("/dev/null", O_RDONLY);
 253     dup2 (fd, STDIN_FILENO);
 254     close (fd);
 255
 256     /* Close stdout */
 257     fd = open ("/dev/null", O_WRONLY);
 258     dup2 (fd, STDOUT_FILENO);
 259     close (fd);
 260
 261     /* Get the pipe from the daemon */
 262     if (argc != 4)
 263     {
 264         g_printerr ("Usage: lightdm --session-child INPUTFD OUTPUTFD\n");
 265         return EXIT_FAILURE;
 266     }
 267     from_daemon_output = atoi (argv[2]);
 268     to_daemon_input = atoi (argv[3]);
 269     if (from_daemon_output == 0 || to_daemon_input == 0)
 270     {
 271         g_printerr ("Invalid file descriptors %s %s\n", argv[2], argv[3]);
 272         return EXIT_FAILURE;
 273     }
 274
 275     /* Don't let these pipes leak to the command we will run */
 276     fcntl (from_daemon_output, F_SETFD, FD_CLOEXEC);
 277     fcntl (to_daemon_input, F_SETFD, FD_CLOEXEC);
 278
 279     /* Read a version number so we can handle upgrades (i.e. a newer version of session child is run for an old daemon */
 280     read_data (&version, sizeof (version));
 281
 282     service = read_string ();
 283     username = read_string ();
 284     read_data (&do_authenticate, sizeof (do_authenticate));
 285     read_data (&is_interactive, sizeof (is_interactive));
 286     read_string (); /* Used to be class, now we just use the environment variable */
 287     tty = read_string ();
 288     remote_host_name = read_string ();
 289     xdisplay = read_string ();
 290     x_authority = read_xauth ();
 291
 292     /* Setup PAM */
 293     result = pam_start (service, username, &conversation, &pam_handle);
 294     if (result != PAM_SUCCESS)
 295     {
 296         g_printerr ("Failed to start PAM: %s", pam_strerror (NULL, result));
 297         return EXIT_FAILURE;
 298     }
 299     if (xdisplay)
 300     {
 301 #ifdef PAM_XDISPLAY
 302         pam_set_item (pam_handle, PAM_XDISPLAY, xdisplay);
 303 #endif
 304         pam_set_item (pam_handle, PAM_TTY, xdisplay);
 305     }
 306     else if (tty)
 307         pam_set_item (pam_handle, PAM_TTY, tty);
 308
 309 #ifdef PAM_XAUTHDATA
 310     if (x_authority)
 311     {
 312         struct pam_xauth_data value;
 313
 314         value.name = (char *) x_authority_get_authorization_name (x_authority);
 315         value.namelen = strlen (x_authority_get_authorization_name (x_authority));
 316         value.data = (char *) x_authority_get_authorization_data (x_authority);
 317         value.datalen = x_authority_get_authorization_data_length (x_authority);
 318         pam_set_item (pam_handle, PAM_XAUTHDATA, &value);
 319     }
 320 #endif
 321
 322     /* Authenticate */
 323     if (do_authenticate)
 324     {
 325         const gchar *new_username;
 326
 327         authentication_result = pam_authenticate (pam_handle, 0);
 328
 329         /* See what user we ended up as */
 330         if (pam_get_item (pam_handle, PAM_USER, (const void **) &new_username) != PAM_SUCCESS)
 331             return EXIT_FAILURE;
 332         g_free (username);
 333         username = g_strdup (new_username);
 334
 335         /* Check account is valid */
 336         if (authentication_result == PAM_SUCCESS)
 337             authentication_result = pam_acct_mgmt (pam_handle, 0);
 338         if (authentication_result == PAM_NEW_AUTHTOK_REQD)
 339             authentication_result = pam_chauthtok (pam_handle, 0);
 340     }
 341     else
 342         authentication_result = PAM_SUCCESS;
 343     authentication_complete = TRUE;
 344
 345     if (authentication_result == PAM_SUCCESS)
 346     {
 347         /* Fail authentication if user doesn't actually exist */
 348         user = accounts_get_user_by_name (username);
 349         if (!user)
 350         {
 351             g_printerr ("Failed to get information on user %s: %s\n", username, strerror (errno));
 352             authentication_result = PAM_USER_UNKNOWN;
 353         }
 354         else
 355         {
 356             /* Set POSIX variables */
 357             pam_putenv (pam_handle, "PATH=/usr/local/bin:/usr/bin:/bin");
 358             pam_putenv (pam_handle, g_strdup_printf ("USER=%s", username));
 359             pam_putenv (pam_handle, g_strdup_printf ("LOGNAME=%s", username));
 360             pam_putenv (pam_handle, g_strdup_printf ("HOME=%s", user_get_home_directory (user)));
 361             pam_putenv (pam_handle, g_strdup_printf ("SHELL=%s", user_get_shell (user)));
 362
 363             /* Let the greeter and user session inherit the system default locale */
 364             for (i = 0; locale_var_names[i] != NULL; i++)
 365             {
 366                 if ((locale_value = g_getenv (locale_var_names[i])) != NULL)
 367                 {
 368                     locale_var = g_strdup_printf ("%s=%s", locale_var_names[i], locale_value);
 369                     pam_putenv (pam_handle, locale_var);
 370                     g_free (locale_var);
 371                 }
 372             }
 373         }
 374     }
 375
 376     authentication_result_string = g_strdup (pam_strerror (pam_handle, authentication_result));
 377
 378     /* Report authentication result */
 379     write_string (username);
 380     write_data (&auth_complete, sizeof (auth_complete));
 381     write_data (&authentication_result, sizeof (authentication_result));
 382     write_string (authentication_result_string);
 383
 384     /* Check we got a valid user */
 385     if (!username)
 386     {
 387         g_printerr ("No user selected during authentication\n");
 388         return EXIT_FAILURE;
 389     }
 390
 391     /* Stop if we didn't authenticated */
 392     if (authentication_result != PAM_SUCCESS)
 393         return EXIT_FAILURE;
 394
 395     /* Get the command to run (blocks) */
 396     log_filename = read_string ();
 397     if (version >= 1)
 398     {
 399         g_free (tty);
 400         tty = read_string ();
 401     }
 402     x_authority_filename = read_string ();
 403     if (version >= 1)
 404     {
 405         g_free (xdisplay);
 406         xdisplay = read_string ();
 407         if (x_authority)
 408             g_object_unref (x_authority);
 409         x_authority = read_xauth ();
 410     }
 411     read_data (&env_length, sizeof (env_length));
 412     for (i = 0; i < env_length; i++)
 413         pam_putenv (pam_handle, read_string ());
 414     read_data (&command_argc, sizeof (command_argc));
 415     command_argv = g_malloc (sizeof (gchar *) * (command_argc + 1));
 416     for (i = 0; i < command_argc; i++)
 417         command_argv[i] = read_string ();
 418     command_argv[i] = NULL;
 419
 420     /* Redirect stderr to a log file */
 421     if (log_filename)
 422         log_backup_filename = g_strdup_printf ("%s.old", log_filename);
 423     if (!log_filename)
 424     {
 425         fd = open ("/dev/null", O_WRONLY);
 426         dup2 (fd, STDERR_FILENO);
 427         close (fd);
 428     }
 429     else if (g_path_is_absolute (log_filename))
 430     {
 431         rename (log_filename, log_backup_filename);
 432         fd = open (log_filename, O_WRONLY | O_APPEND | O_CREAT, 0600);
 433         dup2 (fd, STDERR_FILENO);
 434         close (fd);
 435     }
 436
 437     /* Set group membership - these can be overriden in pam_setcred */
 438     if (getuid () == 0)
 439     {
 440         if (initgroups (username, user_get_gid (user)) < 0)
 441         {
 442             g_printerr ("Failed to initialize supplementary groups for %s: %s\n", username, strerror (errno));
 443             _exit (EXIT_FAILURE);
 444         }
 445     }
 446
 447     /* Set credentials */
 448     result = pam_setcred (pam_handle, PAM_ESTABLISH_CRED);
 449     if (result != PAM_SUCCESS)
 450     {
 451         g_printerr ("Failed to establish PAM credentials: %s\n", pam_strerror (pam_handle, result));
 452         return EXIT_FAILURE;
 453     }
 454
 455     /* Open the session */
 456     result = pam_open_session (pam_handle, 0);
 457     if (result != PAM_SUCCESS)
 458     {
 459         g_printerr ("Failed to open PAM session: %s\n", pam_strerror (pam_handle, result));
 460         return EXIT_FAILURE;
 461     }
 462
 463     /* Open a connection to the system bus for ConsoleKit - we must keep it open or CK will close the session */
 464     bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
 465     if (error)
 466         g_printerr ("Unable to contact system bus: %s", error->message);
 467     if (!bus)
 468         return EXIT_FAILURE;
 469
 470     if (login1_is_running ())
 471     {
 472         login1_session = login1_get_session_id ();
 473         write_string (login1_session);
 474     }
 475
 476     if (!login1_session)
 477     {
 478         /* Open a Console Kit session */
 479         g_variant_builder_init (&ck_parameters, G_VARIANT_TYPE ("(a(sv))"));
 480         g_variant_builder_open (&ck_parameters, G_VARIANT_TYPE ("a(sv)"));
 481         g_variant_builder_add (&ck_parameters, "(sv)", "unix-user", g_variant_new_int32 (user_get_uid (user)));
 482         if (g_strcmp0 (pam_getenv (pam_handle, "XDG_SESSION_CLASS"), "greeter") == 0)
 483             g_variant_builder_add (&ck_parameters, "(sv)", "session-type", g_variant_new_string ("LoginWindow"));
 484         if (xdisplay)
 485         {
 486             g_variant_builder_add (&ck_parameters, "(sv)", "x11-display", g_variant_new_string (xdisplay));
 487             if (tty)
 488                 g_variant_builder_add (&ck_parameters, "(sv)", "x11-display-device", g_variant_new_string (tty));
 489         }
 490         if (remote_host_name)
 491         {
 492             g_variant_builder_add (&ck_parameters, "(sv)", "is-local", g_variant_new_boolean (FALSE));
 493             g_variant_builder_add (&ck_parameters, "(sv)", "remote-host-name", g_variant_new_string (remote_host_name));
 494         }
 495         else
 496             g_variant_builder_add (&ck_parameters, "(sv)", "is-local", g_variant_new_boolean (TRUE));
 497         console_kit_cookie = ck_open_session (&ck_parameters);
 498         write_string (console_kit_cookie);
 499         if (console_kit_cookie)
 500         {
 501             gchar *value;
 502             value = g_strdup_printf ("XDG_SESSION_COOKIE=%s", console_kit_cookie);
 503             pam_putenv (pam_handle, value);
 504             g_free (value);
 505         }
 506     }
 507
 508     /* Write X authority */
 509     if (x_authority)
 510     {
 511         gboolean drop_privileges, result;
 512         gchar *value;
 513         GError *error = NULL;
 514
 515         drop_privileges = geteuid () == 0;
 516         if (drop_privileges)
 517             privileges_drop (user);
 518         result = x_authority_write (x_authority, XAUTH_WRITE_MODE_REPLACE, x_authority_filename, &error);
 519         if (drop_privileges)
 520             privileges_reclaim ();
 521
 522         if (error)
 523             g_printerr ("Error writing X authority: %s\n", error->message);
 524         g_clear_error (&error);
 525         if (!result)
 526             return EXIT_FAILURE;
 527
 528         value = g_strdup_printf ("XAUTHORITY=%s", x_authority_filename);
 529         pam_putenv (pam_handle, value);
 530         g_free (value);
 531     }
 532
 533     /* Put our tools directory in the path as a hack so we can use the legacy gdmflexiserver interface */
 534     path = pam_getenv (pam_handle, "PATH");
 535     if (path)
 536         pam_putenv (pam_handle, g_strdup_printf ("PATH=%s:%s", PKGLIBEXEC_DIR, path));
 537
 538     /* Catch terminate signal and pass it to the child */
 539     signal (SIGTERM, signal_cb);
 540
 541     /* Run the command as the authenticated user */
 542     child_pid = fork ();
 543     if (child_pid == 0)
 544     {
 545         // FIXME: This is not thread safe (particularly the printfs)
 546
 547         /* Make this process its own session */
 548         if (setsid () < 0)
 549             g_printerr ("Failed to make process a new session: %s\n", strerror (errno));
 550
 551         /* Change to this user */
 552         if (getuid () == 0)
 553         {
 554             if (setgid (user_get_gid (user)) != 0)
 555             {
 556                 g_printerr ("Failed to set group ID to %d: %s\n", user_get_gid (user), strerror (errno));
 557                 _exit (EXIT_FAILURE);
 558             }
 559
 560             if (setuid (user_get_uid (user)) != 0)
 561             {
 562                 g_printerr ("Failed to set user ID to %d: %s\n", user_get_uid (user), strerror (errno));
 563                 _exit (EXIT_FAILURE);
 564             }
 565         }
 566
 567         /* Change working directory */
 568         /* NOTE: This must be done after the permissions are changed because NFS filesystems can
 569          * be setup so the local root user accesses the NFS files as 'nobody'.  If the home directories
 570          * are not system readable then the chdir can fail */
 571         if (chdir (user_get_home_directory (user)) != 0)
 572         {
 573             g_printerr ("Failed to change to home directory %s: %s\n", user_get_home_directory (user), strerror (errno));
 574             _exit (EXIT_FAILURE);
 575         }
 576
 577         /* Redirect stderr to a log file */
 578         if (log_filename && !g_path_is_absolute (log_filename))
 579         {
 580             rename (log_filename, log_backup_filename);
 581             fd = open (log_filename, O_WRONLY | O_APPEND | O_CREAT, 0600);
 582             dup2 (fd, STDERR_FILENO);
 583             close (fd);
 584         }
 585
 586         /* Run the command */
 587         execve (command_argv[0], command_argv, pam_getenvlist (pam_handle));
 588         g_printerr ("Failed to run command: %s\n", strerror (errno));
 589         _exit (EXIT_FAILURE);
 590     }
 591
 592     /* Bail out if failed to fork */
 593     if (child_pid < 0)
 594     {
 595         g_printerr ("Failed to fork session child process: %s\n", strerror (errno));
 596         return_code = EXIT_FAILURE;
 597     }
 598
 599     /* Wait for the command to complete (blocks) */
 600     if (child_pid > 0)
 601     {
 602         /* Log to utmp */
 603         if (g_strcmp0 (pam_getenv (pam_handle, "XDG_SESSION_CLASS"), "greeter") != 0)
 604         {
 605             struct utmpx ut;
 606             struct timeval tv;
 607
 608             memset (&ut, 0, sizeof (ut));
 609             ut.ut_type = USER_PROCESS;
 610             ut.ut_pid = child_pid;
 611             if (tty)
 612                 strncpy (ut.ut_line, tty + strlen ("/dev/"), sizeof (ut.ut_line));
 613             if (xdisplay)
 614                 strncpy (ut.ut_id, xdisplay, sizeof (ut.ut_id));
 615             strncpy (ut.ut_user, username, sizeof (ut.ut_user));
 616             if (xdisplay)
 617                 strncpy (ut.ut_host, xdisplay, sizeof (ut.ut_host));
 618             else if (remote_host_name)
 619                 strncpy (ut.ut_host, remote_host_name, sizeof (ut.ut_host));
 620             gettimeofday (&tv, NULL);
 621             ut.ut_tv.tv_sec = tv.tv_sec;
 622             ut.ut_tv.tv_usec = tv.tv_usec;
 623
 624             setutxent ();
 625             if (!pututxline (&ut))
 626                 g_printerr ("Failed to write utmpx: %s\n", strerror (errno));
 627             endutxent ();
 628         }
 629
 630         waitpid (child_pid, &return_code, 0);
 631         child_pid = 0;
 632
 633         /* Log to utmp */
 634         if (g_strcmp0 (pam_getenv (pam_handle, "XDG_SESSION_CLASS"), "greeter") != 0)
 635         {
 636             struct utmpx ut;
 637             struct timeval tv;
 638
 639             memset (&ut, 0, sizeof (ut));
 640             ut.ut_type = DEAD_PROCESS;
 641             ut.ut_pid = child_pid;
 642             if (tty)
 643                 strncpy (ut.ut_line, tty + strlen ("/dev/"), sizeof (ut.ut_line));
 644             if (xdisplay)
 645                 strncpy (ut.ut_id, xdisplay, sizeof (ut.ut_id));
 646             strncpy (ut.ut_user, username, sizeof (ut.ut_user));
 647             if (xdisplay)
 648                 strncpy (ut.ut_host, xdisplay, sizeof (ut.ut_host));
 649             else if (remote_host_name)
 650                 strncpy (ut.ut_host, remote_host_name, sizeof (ut.ut_host));
 651             gettimeofday (&tv, NULL);
 652             ut.ut_tv.tv_sec = tv.tv_sec;
 653             ut.ut_tv.tv_usec = tv.tv_usec;
 654
 655             setutxent ();
 656             if (!pututxline (&ut))
 657                 g_printerr ("Failed to write utmpx: %s\n", strerror (errno));
 658             endutxent ();
 659         }
 660     }
 661
 662     /* Remove X authority */
 663     if (x_authority)
 664     {
 665         gboolean drop_privileges, result;
 666         GError *error = NULL;
 667
 668         drop_privileges = geteuid () == 0;
 669         if (drop_privileges)
 670             privileges_drop (user);
 671         result = x_authority_write (x_authority, XAUTH_WRITE_MODE_REMOVE, x_authority_filename, &error);
 672         if (drop_privileges)
 673             privileges_reclaim ();
 674
 675         if (error)
 676             g_printerr ("Error removing X authority: %s\n", error->message);
 677         g_clear_error (&error);
 678         if (!result)
 679             _exit (EXIT_FAILURE);
 680     }
 681
 682     /* Close the Console Kit session */
 683     if (console_kit_cookie)
 684         ck_close_session (console_kit_cookie);
 685
 686     /* Close the session */
 687     pam_close_session (pam_handle, 0);
 688
 689     /* Remove credentials */
 690     result = pam_setcred (pam_handle, PAM_DELETE_CRED);
 691
 692     pam_end (pam_handle, 0);
 693     pam_handle = NULL;
 694
 695     /* Return result of session process to the daemon */
 696     return return_code;
 697 }