src/sessiond/tlm-session.c

   1 /* vi: set et sw=4 ts=4 cino=t0,(0: */
   2 /* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   3 /*
   4  * This file is part of tlm (Tizen Login Manager)
   5  *
   6  * Copyright (C) 2013-2014 Intel Corporation.
   7  *
   8  * Contact: Amarnath Valluri <amarnath.valluri@linux.intel.com>
   9  *          Jussi Laako <jussi.laako@linux.intel.com>
  10  *          Imran Zaman <imran.zaman@intel.com>
  11  *
  12  * This library is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2.1 of the License, or (at your option) any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  20  * Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with this library; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  25  * 02110-1301 USA
  26  */
  27
  28 #include <string.h>
  29 #include <errno.h>
  30 #include <stdlib.h>
  31 #include <fcntl.h>
  32 #include <unistd.h>
  33 #include <grp.h>
  34 #include <stdio.h>
  35 #include <signal.h>
  36 #include <termios.h>
  37 #include <libintl.h>
  38 #include <sys/types.h>
  39 #include <sys/stat.h>
  40 #include <sys/wait.h>
  41 #include <sys/ioctl.h>
  42 #include <ctype.h>
  43 #include <sys/socket.h>
  44 #include <netdb.h>
  45
  46 #include <glib.h>
  47 #include <glib/gstdio.h>
  48
  49 #include "tlm-session.h"
  50 #include "tlm-auth-session.h"
  51 #include "common/tlm-log.h"
  52 #include "common/tlm-utils.h"
  53 #include "common/tlm-error.h"
  54 #include "common/tlm-config-general.h"
  55 #include "common/tlm-config-seat.h"
  56
  57 G_DEFINE_TYPE (TlmSession, tlm_session, G_TYPE_OBJECT);
  58
  59 #define TLM_SESSION_PRIV(obj) \
  60     G_TYPE_INSTANCE_GET_PRIVATE ((obj), TLM_TYPE_SESSION, TlmSessionPrivate)
  61
  62 enum {
  63     PROP_0,
  64     PROP_CONFIG,
  65     PROP_SEAT,
  66     PROP_SERVICE,
  67     PROP_USERNAME,
  68     PROP_ENVIRONMENT,
  69     N_PROPERTIES
  70 };
  71 static GParamSpec *pspecs[N_PROPERTIES];
  72
  73 enum {
  74     SIG_SESSION_CREATED,
  75     SIG_SESSION_TERMINATED,
  76     SIG_AUTHENTICATED,
  77     SIG_SESSION_ERROR,
  78     SIG_MAX
  79 };
  80 static guint signals[SIG_MAX];
  81
  82 struct _TlmSessionPrivate
  83 {
  84     TlmConfig *config;
  85     pid_t child_pid;
  86     uid_t tty_uid;
  87     gid_t tty_gid;
  88     unsigned vtnr;
  89     struct termios stdin_state, stdout_state, stderr_state;
  90     gchar *seat_id;
  91     gchar *service;
  92     gchar *username;
  93     GHashTable *env_hash;
  94     TlmAuthSession *auth_session;
  95     int last_sig;
  96     guint timer_id;
  97     guint child_watch_id;
  98     gchar *sessionid;
  99     gchar *xdg_runtime_dir;
 100     gboolean setup_runtime_dir;
 101     gboolean can_emit_signal;
 102     gboolean is_child_up;
 103     gboolean session_pause;
 104 };
 105
 106 static void
 107 _clear_session (TlmSession *session)
 108 {
 109     tlm_session_reset_tty (session);
 110     if (session->priv->setup_runtime_dir)
 111         tlm_utils_delete_dir (session->priv->xdg_runtime_dir);
 112
 113     if (session->priv->timer_id) {
 114         g_source_remove (session->priv->timer_id);
 115         session->priv->timer_id = 0;
 116     }
 117
 118     if (session->priv->child_watch_id) {
 119         g_source_remove (session->priv->child_watch_id);
 120         session->priv->child_watch_id = 0;
 121     }
 122
 123     if (session->priv->auth_session)
 124         g_clear_object (&session->priv->auth_session);
 125
 126     if (session->priv->env_hash) {
 127         g_hash_table_unref (session->priv->env_hash);
 128         session->priv->env_hash = NULL;
 129     }
 130     g_clear_string (&session->priv->seat_id);
 131     g_clear_string (&session->priv->service);
 132     g_clear_string (&session->priv->username);
 133     g_clear_string (&session->priv->sessionid);
 134     g_clear_string (&session->priv->xdg_runtime_dir);
 135 }
 136
 137 static void
 138 tlm_session_dispose (GObject *self)
 139 {
 140     TlmSession *session = TLM_SESSION(self);
 141     TlmSessionPrivate *priv = session->priv;
 142     DBG("disposing session: %s", priv->service);
 143     priv->can_emit_signal = FALSE;
 144
 145     tlm_session_terminate (session);
 146     while (priv->is_child_up)
 147         g_main_context_iteration(NULL, TRUE);
 148
 149     g_clear_object (&session->priv->config);
 150
 151     G_OBJECT_CLASS (tlm_session_parent_class)->dispose (self);
 152 }
 153
 154 static void
 155 tlm_session_finalize (GObject *self)
 156 {
 157     //TlmSession *session = TLM_SESSION(self);
 158     G_OBJECT_CLASS (tlm_session_parent_class)->finalize (self);
 159 }
 160
 161 static void
 162 _session_set_property (GObject *obj,
 163                        guint property_id,
 164                        const GValue *value,
 165                        GParamSpec *pspec)
 166 {
 167     TlmSession *session = TLM_SESSION(obj);
 168     TlmSessionPrivate *priv = TLM_SESSION_PRIV (session);
 169
 170     switch (property_id) {
 171         case PROP_CONFIG:
 172             priv->config = g_value_dup_object (value);
 173             break;
 174         case PROP_SEAT:
 175             g_free (priv->seat_id);
 176             priv->seat_id = g_value_dup_string (value);
 177             break;
 178         case PROP_SERVICE:
 179             priv->service = g_value_dup_string (value);
 180             break;
 181         case PROP_USERNAME:
 182             priv->username = g_value_dup_string (value);
 183             break;
 184         case PROP_ENVIRONMENT:
 185             priv->env_hash = (GHashTable *) g_value_get_pointer (value);
 186             if (priv->env_hash)
 187                 g_hash_table_ref (priv->env_hash);
 188             break;
 189         default:
 190             G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, property_id, pspec);
 191     }
 192 }
 193
 194 static void
 195 _session_get_property (GObject *obj,
 196                        guint property_id,
 197                        GValue *value,
 198                        GParamSpec *pspec)
 199 {
 200     TlmSession *session = TLM_SESSION(obj);
 201     TlmSessionPrivate *priv = TLM_SESSION_PRIV (session);
 202
 203     switch (property_id) {
 204         case PROP_CONFIG:
 205             g_value_set_object (value, priv->config);
 206             break;
 207         case PROP_SEAT:
 208             g_value_set_string (value, priv->seat_id);
 209             break;
 210         case PROP_SERVICE:
 211             g_value_set_string (value, priv->service);
 212             break;
 213         case PROP_USERNAME:
 214             g_value_set_string (value, priv->username);
 215             break;
 216         case PROP_ENVIRONMENT:
 217             g_value_set_pointer (value, priv->env_hash);
 218             break;
 219         default:
 220             G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, property_id, pspec);
 221     }
 222 }
 223
 224 static void
 225 tlm_session_class_init (TlmSessionClass *klass)
 226 {
 227     GObjectClass *g_klass = G_OBJECT_CLASS (klass);
 228
 229     g_type_class_add_private (klass, sizeof (TlmSessionPrivate));
 230
 231     g_klass->dispose = tlm_session_dispose ;
 232     g_klass->finalize = tlm_session_finalize;
 233     g_klass->set_property = _session_set_property;
 234     g_klass->get_property = _session_get_property;
 235
 236     pspecs[PROP_CONFIG] =
 237         g_param_spec_object ("config",
 238                              "config object",
 239                              "Configuration object",
 240                              TLM_TYPE_CONFIG,
 241                              G_PARAM_READWRITE|
 242                              G_PARAM_STATIC_STRINGS);
 243     pspecs[PROP_SEAT] =
 244         g_param_spec_string ("seat",
 245                              "seat id",
 246                              "Seat id string",
 247                              NULL,
 248                              G_PARAM_READWRITE|G_PARAM_STATIC_STRINGS);
 249     pspecs[PROP_SERVICE] =
 250         g_param_spec_string ("service",
 251                              "authentication service",
 252                              "PAM service",
 253                              NULL,
 254                              G_PARAM_READWRITE|G_PARAM_STATIC_STRINGS);
 255     pspecs[PROP_USERNAME] =
 256         g_param_spec_string ("username",
 257                              "user name",
 258                              "Unix user name of user to login",
 259                              NULL,
 260                              G_PARAM_READWRITE|G_PARAM_STATIC_STRINGS);
 261     pspecs[PROP_ENVIRONMENT] =
 262         g_param_spec_pointer ("environment",
 263                               "environment variables",
 264                               "Environment variables for the session",
 265                               G_PARAM_READWRITE|G_PARAM_STATIC_STRINGS);
 266
 267     g_object_class_install_properties (g_klass, N_PROPERTIES, pspecs);
 268
 269     signals[SIG_SESSION_CREATED] = g_signal_new ("session-created",
 270                                 TLM_TYPE_SESSION, G_SIGNAL_RUN_LAST,
 271                                 0, NULL, NULL, NULL, G_TYPE_NONE,
 272                                 1, G_TYPE_STRING);
 273
 274     signals[SIG_SESSION_TERMINATED] = g_signal_new ("session-terminated",
 275                                 TLM_TYPE_SESSION, G_SIGNAL_RUN_LAST,
 276                                 0, NULL, NULL, NULL, G_TYPE_NONE,
 277                                 0, G_TYPE_NONE);
 278
 279     signals[SIG_AUTHENTICATED] = g_signal_new ("authenticated",
 280                                 TLM_TYPE_SESSION, G_SIGNAL_RUN_LAST,
 281                                 0, NULL, NULL, NULL, G_TYPE_NONE,
 282                                 0, G_TYPE_NONE);
 283
 284     signals[SIG_SESSION_ERROR] = g_signal_new ("session-error",
 285                                 TLM_TYPE_SESSION, G_SIGNAL_RUN_LAST,
 286                                 0, NULL, NULL, NULL, G_TYPE_NONE,
 287                                 1, G_TYPE_ERROR);
 288
 289 }
 290
 291 static void
 292 tlm_session_init (TlmSession *session)
 293 {
 294     TlmSessionPrivate *priv = TLM_SESSION_PRIV (session);
 295
 296     priv->service = NULL;
 297     priv->env_hash = NULL;
 298     priv->auth_session = NULL;
 299     priv->sessionid = NULL;
 300     priv->child_watch_id = 0;
 301     priv->is_child_up = FALSE;
 302     priv->can_emit_signal = TRUE;
 303     priv->config = tlm_config_new ();
 304
 305     session->priv = priv;
 306
 307     struct stat tty_stat;
 308
 309     if (fstat (0, &tty_stat) == 0) {
 310         priv->tty_uid = tty_stat.st_uid;
 311         priv->tty_gid = tty_stat.st_gid;
 312     } else {
 313         priv->tty_uid = 0;
 314         priv->tty_gid = 0;
 315     }
 316
 317     if (tcgetattr (0, &priv->stdin_state) ||
 318         tcgetattr (1, &priv->stdout_state) ||
 319         tcgetattr (2, &priv->stderr_state))
 320         WARN ("Failed to retrieve initial terminal state");
 321 }
 322
 323 static void
 324 _setenv_to_session (const gchar *key, const gchar *val,
 325                     TlmSessionPrivate *user_data)
 326 {
 327     TlmSessionPrivate *priv = (TlmSessionPrivate *) user_data;
 328     if (priv->session_pause)
 329         tlm_auth_session_set_env (priv->auth_session,
 330                                   (const gchar *) key,
 331                                   (const gchar *) val);
 332     else
 333         setenv ((const char *) key, (const char *) val, 1);
 334 }
 335
 336 static gboolean
 337 _set_terminal (TlmSessionPrivate *priv)
 338 {
 339     gboolean res = TRUE;
 340     int i;
 341     int tty_fd;
 342     pid_t tty_pgid;
 343     gchar *tty_dev = NULL;
 344     struct stat tty_stat;
 345
 346     DBG ("VTNR is %u", priv->vtnr);
 347     if (priv->vtnr > 0) {
 348         tty_dev = g_strdup_printf ("/dev/tty%u", priv->vtnr);
 349     } else {
 350         tty_dev = g_strdup (ttyname (0));
 351     }
 352     DBG ("trying to setup TTY '%s'", tty_dev);
 353     if (!tty_dev) {
 354         WARN ("No TTY");
 355         res = FALSE;
 356         goto term_exit;
 357     }
 358     if (access (tty_dev, R_OK|W_OK)) {
 359         WARN ("TTY not accessible: %s", strerror(errno));
 360         res = FALSE;
 361         goto term_exit;
 362     }
 363     if (lstat (tty_dev, &tty_stat)) {
 364         WARN ("lstat() failed: %s", strerror(errno));
 365         res = FALSE;
 366         goto term_exit;
 367     }
 368     if (tty_stat.st_nlink > 1 ||
 369         !S_ISCHR (tty_stat.st_mode) ||
 370         strncmp (tty_dev, "/dev/", 5)) {
 371         WARN ("Invalid TTY");
 372         res = FALSE;
 373         goto term_exit;
 374     }
 375
 376     tty_fd = open (tty_dev, O_RDWR | O_NONBLOCK);
 377     if (tty_fd < 0) {
 378         WARN ("open() failed: %s", strerror(errno));
 379         res = FALSE;
 380         goto term_exit;
 381     }
 382     if (!isatty (tty_fd)) {
 383         close (tty_fd);
 384         WARN ("isatty() failed");
 385         res = FALSE;
 386         goto term_exit;
 387     }
 388     if (ioctl (tty_fd, TIOCSCTTY, 1))
 389         WARN ("ioctl(TIOCSCTTY) failed: %s", strerror(errno));
 390     tty_pgid = getpgid (getpid ());
 391     if (ioctl (tty_fd, TIOCSPGRP, &tty_pgid)) {
 392         WARN ("ioctl(TIOCSPGRP) failed: %s", strerror(errno));
 393     }
 394     /*if (tcsetpgrp (tty_fd, getpgrp ()))
 395         WARN ("tcsetpgrp() failed: %s", strerror(errno));*/
 396
 397     // close all old handles
 398     for (i = 0; i < tty_fd; i++)
 399         close (i);
 400     dup2 (tty_fd, 0);
 401     dup2 (tty_fd, 1);
 402     dup2 (tty_fd, 2);
 403     close (tty_fd);
 404
 405 term_exit:
 406     g_free (tty_dev);
 407     return res;
 408 }
 409
 410 static gboolean
 411 _set_environment (TlmSessionPrivate *priv)
 412 {
 413         gchar **envlist = tlm_auth_session_get_envlist(priv->auth_session);
 414         const gchar *home_dir = NULL, *shell = NULL;
 415
 416     if (envlist) {
 417         gchar **env = 0;
 418         for (env = envlist; *env != NULL; ++env) {
 419             DBG ("ENV : %s", *env);
 420             putenv(*env);
 421             g_free (*env);
 422         }
 423         g_free (envlist);
 424     }
 425
 426     const gchar *path = tlm_config_get_string (priv->config,
 427                                                TLM_CONFIG_GENERAL,
 428                                                TLM_CONFIG_GENERAL_SESSION_PATH);
 429     if (!path)
 430         path = "/usr/local/bin:/usr/bin:/bin";
 431     _setenv_to_session ("PATH", path, priv);
 432
 433     _setenv_to_session ("USER", priv->username, priv);
 434     _setenv_to_session ("LOGNAME", priv->username, priv);
 435     home_dir = tlm_user_get_home_dir (priv->username);
 436     if (home_dir) _setenv_to_session ("HOME", home_dir, priv);
 437     shell = tlm_user_get_shell (priv->username);
 438     if (shell) _setenv_to_session ("SHELL", shell, priv);
 439     // TODO: figure out if this should be set or not for logical seats (NSEATS)
 440     if (priv->seat_id) _setenv_to_session ("XDG_SEAT", priv->seat_id, priv);
 441
 442     const gchar *xdg_data_dirs =
 443         tlm_config_get_string (priv->config,
 444                                TLM_CONFIG_GENERAL,
 445                                TLM_CONFIG_GENERAL_DATA_DIRS);
 446     if (!xdg_data_dirs)
 447         xdg_data_dirs = "/usr/share:/usr/local/share";
 448     _setenv_to_session ("XDG_DATA_DIRS", xdg_data_dirs, priv);
 449
 450     if (priv->xdg_runtime_dir)
 451         _setenv_to_session ("XDG_RUNTIME_DIR", priv->xdg_runtime_dir, priv);
 452
 453     if (priv->env_hash)
 454         g_hash_table_foreach (priv->env_hash,
 455                               (GHFunc) _setenv_to_session,
 456                               priv);
 457
 458     return TRUE;
 459 }
 460
 461 static void
 462 _on_child_down_cb (
 463         GPid  pid,
 464         gint  status,
 465         gpointer data)
 466 {
 467     g_spawn_close_pid (pid);
 468
 469     TlmSession *session = TLM_SESSION (data);
 470
 471     DBG ("Sessiond(%p) with pid (%d) closed with status %d", session, pid,
 472             status);
 473
 474     session->priv->child_pid = 0;
 475     session->priv->is_child_up = FALSE;
 476     _clear_session (session);
 477     if (session->priv->can_emit_signal)
 478         g_signal_emit (session, signals[SIG_SESSION_TERMINATED], 0);
 479 }
 480
 481 static void
 482 _exec_user_session (
 483                 TlmSession *session)
 484 {
 485     gint i;
 486     guint rtdir_perm = 0700;
 487     const gchar *pattern = "('.*?'|\".*?\"|\\S+)";
 488     const gchar *rtdir_perm_str;
 489     const char *home;
 490     const char *shell = NULL;
 491     const char *env_shell = NULL;
 492     gchar *uid_str;
 493     gchar **args = NULL;
 494     gchar **args_iter = NULL;
 495     TlmSessionPrivate *priv = session->priv;
 496     gchar **temp_strv = NULL;
 497
 498     priv = session->priv;
 499     if (!priv->username)
 500         priv->username = g_strdup (tlm_auth_session_get_username (
 501                 priv->auth_session));
 502     DBG ("session ID : %s", priv->sessionid);
 503
 504     if (tlm_config_has_key (priv->config,
 505                             priv->seat_id,
 506                             TLM_CONFIG_GENERAL_SETUP_RUNTIME_DIR)) {
 507         priv->setup_runtime_dir = tlm_config_get_boolean (priv->config,
 508                                            priv->seat_id,
 509                                            TLM_CONFIG_GENERAL_SETUP_RUNTIME_DIR,
 510                                            FALSE);
 511     } else {
 512         priv->setup_runtime_dir = tlm_config_get_boolean (priv->config,
 513                                            TLM_CONFIG_GENERAL,
 514                                            TLM_CONFIG_GENERAL_SETUP_RUNTIME_DIR,
 515                                            FALSE);
 516     }
 517     rtdir_perm_str = tlm_config_get_string (priv->config,
 518                                             priv->seat_id,
 519                                             TLM_CONFIG_GENERAL_RUNTIME_MODE);
 520     if (!rtdir_perm_str)
 521         rtdir_perm_str = tlm_config_get_string (priv->config,
 522                                                TLM_CONFIG_GENERAL,
 523                                                TLM_CONFIG_GENERAL_RUNTIME_MODE);
 524     uid_str = g_strdup_printf ("%u", tlm_user_get_uid (priv->username));
 525     priv->xdg_runtime_dir = g_build_filename ("/run/user",
 526                                               uid_str,
 527                                               NULL);
 528     g_free (uid_str);
 529     if (priv->setup_runtime_dir) {
 530         tlm_utils_delete_dir (priv->xdg_runtime_dir);
 531         if (g_mkdir_with_parents ("/run/user", 0755))
 532             WARN ("g_mkdir_with_parents(\"/run/user\") failed");
 533         if (rtdir_perm_str)
 534             sscanf(rtdir_perm_str, "%o", &rtdir_perm);
 535         DBG ("setting up XDG_RUNTIME_DIR=%s mode=%o",
 536              priv->xdg_runtime_dir, rtdir_perm);
 537         if (g_mkdir (priv->xdg_runtime_dir, rtdir_perm))
 538             WARN ("g_mkdir(\"%s\") failed", priv->xdg_runtime_dir);
 539         if (chown (priv->xdg_runtime_dir,
 540                tlm_user_get_uid (priv->username),
 541                tlm_user_get_gid (priv->username)))
 542             WARN ("chown(\"%s\"): %s", priv->xdg_runtime_dir, strerror(errno));
 543         if (chmod (priv->xdg_runtime_dir, rtdir_perm))
 544             WARN ("chmod(\"%s\"): %s", priv->xdg_runtime_dir, strerror(errno));
 545     } else {
 546         DBG ("not setting up XDG_RUNTIME_DIR");
 547     }
 548
 549     priv->child_pid = fork ();
 550     if (priv->child_pid) {
 551         DBG ("establish handler for the child pid %u", priv->child_pid);
 552         session->priv->child_watch_id = g_child_watch_add (priv->child_pid,
 553                     (GChildWatchFunc)_on_child_down_cb, session);
 554         session->priv->is_child_up = TRUE;
 555         return;
 556     }
 557
 558     /* ==================================
 559      * this is child process here onwards
 560      * ================================== */
 561     gint open_max;
 562     gint fd;
 563
 564     //close all open descriptors other than stdin, stdout, stderr
 565     open_max = sysconf (_SC_OPEN_MAX);
 566     for (fd = 3; fd < open_max; fd++)
 567         fcntl (fd, F_SETFD, FD_CLOEXEC);
 568
 569     uid_t target_uid = tlm_user_get_uid (priv->username);
 570     gid_t target_gid = tlm_user_get_gid (priv->username);
 571
 572     if (fchown (0, target_uid, -1)) {
 573         WARN ("Changing TTY access rights failed");
 574     }
 575
 576     /*if (getppid() == 1) {
 577         if (setsid () == (pid_t) -1)
 578             WARN ("setsid() failed: %s", strerror (errno));
 579     } else {
 580         if (setpgrp ())
 581             WARN ("setpgrp() failed: %s", strerror (errno));
 582     }*/
 583
 584     DBG ("old pgid=%u", getpgrp ());
 585     if (setsid () == (pid_t) -1)
 586         WARN ("setsid() failed: %s", strerror (errno));
 587     DBG ("new pgid=%u", getpgrp());
 588
 589     gboolean setup_terminal;
 590     if (tlm_config_has_key (priv->config,
 591                             priv->seat_id,
 592                             TLM_CONFIG_GENERAL_SETUP_TERMINAL)) {
 593         setup_terminal = tlm_config_get_boolean (priv->config,
 594                                                  priv->seat_id,
 595                                                  TLM_CONFIG_GENERAL_SETUP_TERMINAL,
 596                                                  FALSE);
 597     } else {
 598         setup_terminal = tlm_config_get_boolean (priv->config,
 599                                                  TLM_CONFIG_GENERAL,
 600                                                  TLM_CONFIG_GENERAL_SETUP_TERMINAL,
 601                                                  FALSE);
 602     }
 603     if (setup_terminal) {
 604         /* usually terminal settings are handled by PAM */
 605         _set_terminal (priv);
 606     }
 607
 608     if (initgroups (priv->username, target_gid))
 609         WARN ("initgroups() failed: %s", strerror(errno));
 610     if (setregid (target_gid, target_gid))
 611         WARN ("setregid() failed: %s", strerror(errno));
 612     if (setreuid (target_uid, target_uid))
 613         WARN ("setreuid() failed: %s", strerror(errno));
 614
 615     int grouplist_len = NGROUPS_MAX;
 616     gid_t grouplist[NGROUPS_MAX];
 617     grouplist_len = getgroups (grouplist_len, grouplist);
 618     DBG ("group membership:");
 619     for (i = 0; i < grouplist_len; i++)
 620         DBG ("\t%s", getgrgid (grouplist[i])->gr_name);
 621
 622     DBG (" state:\n\truid=%d, euid=%d, rgid=%d, egid=%d (%s)",
 623          getuid(), geteuid(), getgid(), getegid(), priv->username);
 624     _set_environment (priv);
 625     umask(0077);
 626
 627     home = getenv("HOME");
 628     if (home) {
 629         DBG ("changing directory to : %s", home);
 630         if (chdir (home) < 0)
 631             WARN ("Failed to change directroy : %s", strerror (errno));
 632     } else WARN ("Could not get home directory");
 633
 634     shell = tlm_config_get_string (priv->config,
 635                                    priv->seat_id,
 636                                    TLM_CONFIG_GENERAL_SESSION_CMD);
 637     if (!shell)
 638         shell = tlm_config_get_string (priv->config,
 639                                        TLM_CONFIG_GENERAL,
 640                                        TLM_CONFIG_GENERAL_SESSION_CMD);
 641     if (shell) {
 642         DBG ("Session command : %s", shell);
 643         temp_strv = g_regex_split_simple (pattern,
 644                                           shell,
 645                                           0,
 646                                           G_REGEX_MATCH_NOTEMPTY);
 647     }
 648
 649     if (temp_strv) {
 650         gchar **temp_iter;
 651
 652         args = g_new0 (gchar *, g_strv_length (temp_strv));
 653         for (temp_iter = temp_strv, args_iter = args;
 654                 *temp_iter != NULL;
 655                 temp_iter++) {
 656             size_t item_len = 0;
 657             gchar *item = g_strstrip (*temp_iter);
 658
 659             item_len = strlen (item);
 660             if (item_len == 0) {
 661                 continue;
 662             }
 663             if ((item[0] == '\"' && item[item_len - 1] == '\"') ||
 664                     (item[0] == '\'' && item[item_len - 1] == '\'')) {
 665                 item[item_len - 1] = '\0';
 666                 memmove (item, item + 1, item_len - 1);
 667             }
 668             *args_iter = g_strcompress (item);
 669             args_iter++;
 670         }
 671         g_strfreev (temp_strv);
 672     } else if ((env_shell = getenv("SHELL"))){
 673         /* use shell if no override configured */
 674         args = g_new0 (gchar *, 2);
 675         args[0] = g_strdup (env_shell);
 676     } else {
 677         /* in case shell is not defined, fall back to systemd --user */
 678         args = g_new0 (gchar *, 3);
 679         args[0] = g_strdup ("systemd");
 680         args[1] = g_strdup ("--user");
 681     }
 682
 683     DBG ("executing: ");
 684     args_iter = args;
 685     while (args_iter && *args_iter) {
 686         DBG ("\targv[%d]: %s", i, *args_iter);
 687         args_iter++; i++;
 688     }
 689     execvp (args[0], args);
 690     /* we reach here only in case of error */
 691     g_strfreev (args);
 692     DBG ("execl(): %s", strerror(errno));
 693     exit (0);
 694 }
 695
 696 TlmSession *
 697 tlm_session_new ()
 698 {
 699     DBG ("Session New");
 700     return g_object_new (TLM_TYPE_SESSION, NULL);
 701 }
 702
 703 gboolean
 704 tlm_session_start (TlmSession *session,
 705                    const gchar *seat_id, const gchar *service,
 706                    const gchar *username, const gchar *password,
 707                    GHashTable *environment)
 708 {
 709         GError *error = NULL;
 710         g_return_val_if_fail (session && TLM_IS_SESSION(session), FALSE);
 711     TlmSessionPrivate *priv = TLM_SESSION_PRIV(session);
 712     const gchar *session_type;
 713
 714     if (!seat_id || !service || !username) {
 715         error = TLM_GET_ERROR_FOR_ID (TLM_ERROR_SESSION_CREATION_FAILURE,
 716                 "Unable to create PAM sesssion as input data is invalid "
 717                 "seatid(%p) service(%p) username(%p)", seat_id, service,
 718                 username);
 719         g_signal_emit (session, signals[SIG_SESSION_ERROR], 0, error);
 720         g_error_free (error);
 721         return FALSE;
 722     }
 723
 724     g_object_set (G_OBJECT (session), "seat", seat_id, "service", service,
 725             "username", username, "environment", environment, NULL);
 726
 727     priv->auth_session = tlm_auth_session_new (priv->service, priv->username,
 728             password);
 729
 730     if (!priv->auth_session) {
 731         error = TLM_GET_ERROR_FOR_ID (TLM_ERROR_SESSION_CREATION_FAILURE,
 732                 "Unable to create PAM sesssion");
 733         g_signal_emit (session, signals[SIG_SESSION_ERROR], 0, error);
 734         g_error_free (error);
 735         return FALSE;
 736     }
 737
 738     priv->vtnr = tlm_config_get_uint (priv->config,
 739                                       priv->seat_id,
 740                                       TLM_CONFIG_SEAT_VTNR,
 741                                       0);
 742     session_type = tlm_config_get_string (priv->config,
 743                                           priv->seat_id,
 744                                           TLM_CONFIG_GENERAL_SESSION_TYPE);
 745     if (!session_type)
 746         session_type = tlm_config_get_string (priv->config,
 747                                               TLM_CONFIG_GENERAL,
 748                                               TLM_CONFIG_GENERAL_SESSION_TYPE);
 749     if (tlm_config_has_key (priv->config,
 750                             TLM_CONFIG_GENERAL,
 751                             TLM_CONFIG_GENERAL_NSEATS))
 752         tlm_auth_session_putenv (priv->auth_session,
 753                                  "XDG_SEAT",
 754                                  priv->seat_id);
 755     if (session_type) {
 756         tlm_auth_session_putenv (priv->auth_session,
 757                                  "XDG_SESSION_CLASS",
 758                                  "user");
 759         tlm_auth_session_putenv (priv->auth_session,
 760                                  "XDG_SESSION_TYPE",
 761                                  session_type);
 762     }
 763     if (priv->vtnr > 0) {
 764         gchar *vtnr_str = g_strdup_printf("%u", priv->vtnr);
 765         tlm_auth_session_putenv (priv->auth_session,
 766                                  "XDG_VTNR",
 767                                  vtnr_str);
 768         g_free (vtnr_str);
 769     }
 770
 771     if (!tlm_auth_session_authenticate (priv->auth_session, &error)) {
 772         if (error) {
 773             //consistant error message flow
 774             GError *err = TLM_GET_ERROR_FOR_ID (
 775                     TLM_ERROR_SESSION_CREATION_FAILURE,
 776                     "%d:%s", error->code, error->message);
 777             g_error_free (error);
 778             error = err;
 779         } else {
 780             error = TLM_GET_ERROR_FOR_ID (TLM_ERROR_SESSION_CREATION_FAILURE,
 781                     "Unable to authenticate PAM sesssion");
 782         }
 783         g_signal_emit (session, signals[SIG_SESSION_ERROR], 0, error);
 784         g_error_free (error);
 785         return FALSE;
 786     }
 787     g_signal_emit (session, signals[SIG_AUTHENTICATED], 0);
 788
 789     priv->session_pause =  tlm_config_get_boolean (priv->config,
 790                                              TLM_CONFIG_GENERAL,
 791                                              TLM_CONFIG_GENERAL_PAUSE_SESSION,
 792                                              FALSE);
 793     if (priv->session_pause) {
 794         _set_environment (priv);
 795         umask(0077);
 796     }
 797
 798     if (!tlm_auth_session_open (priv->auth_session, &error)) {
 799         if (!error) {
 800             error = TLM_GET_ERROR_FOR_ID (TLM_ERROR_SESSION_CREATION_FAILURE,
 801                     "Unable to open PAM sesssion");
 802         }
 803         g_signal_emit (session, signals[SIG_SESSION_ERROR], 0, error);
 804         g_error_free (error);
 805         return FALSE;
 806     }
 807     priv->sessionid = g_strdup (tlm_auth_session_get_sessionid (
 808             priv->auth_session));
 809     tlm_utils_log_utmp_entry (priv->username);
 810     if (!priv->session_pause)
 811         _exec_user_session (session);
 812     g_signal_emit (session, signals[SIG_SESSION_CREATED], 0,
 813                    priv->sessionid ? priv->sessionid : "");
 814     return TRUE;
 815 }
 816
 817 static gboolean
 818 _terminate_timeout (gpointer user_data)
 819 {
 820     TlmSession *session = TLM_SESSION(user_data);
 821     TlmSessionPrivate *priv = TLM_SESSION_PRIV(session);
 822
 823     switch (priv->last_sig)
 824     {
 825         case SIGHUP:
 826             DBG ("child %u didn't respond to SIGHUP, sending SIGTERM",
 827                  priv->child_pid);
 828             if (killpg (getpgid (priv->child_pid), SIGTERM))
 829                 WARN ("killpg(%u, SIGTERM): %s",
 830                       getpgid (priv->child_pid),
 831                       strerror(errno));
 832             priv->last_sig = SIGTERM;
 833             return G_SOURCE_CONTINUE;
 834         case SIGTERM:
 835             DBG ("child %u didn't respond to SIGTERM, sending SIGKILL",
 836                  priv->child_pid);
 837             if (killpg (getpgid (priv->child_pid), SIGKILL))
 838                 WARN ("killpg(%u, SIGKILL): %s",
 839                       getpgid (priv->child_pid),
 840                       strerror(errno));
 841             priv->last_sig = SIGKILL;
 842             return G_SOURCE_CONTINUE;
 843         case SIGKILL:
 844             DBG ("child %u didn't respond to SIGKILL, process is stuck in kernel",
 845                  priv->child_pid);
 846             priv->timer_id = 0;
 847             _clear_session (session);
 848             if (session->priv->can_emit_signal) {
 849                 GError *error = TLM_GET_ERROR_FOR_ID (
 850                         TLM_ERROR_SESSION_TERMINATION_FAILURE,
 851                         "Unable to terminate session - process is stuck"
 852                         " in kernel");
 853                 g_signal_emit (session, signals[SIG_SESSION_ERROR], 0, error);
 854                 g_error_free (error);
 855             }
 856             return G_SOURCE_REMOVE;
 857         default:
 858             WARN ("%d has unknown signaling state %d",
 859                   priv->child_pid,
 860                   priv->last_sig);
 861     }
 862     return G_SOURCE_REMOVE;
 863 }
 864
 865 void
 866 tlm_session_terminate (TlmSession *session)
 867 {
 868     g_return_if_fail (session && TLM_IS_SESSION(session));
 869     TlmSessionPrivate *priv = TLM_SESSION_PRIV(session);
 870
 871     DBG ("Session Terminate");
 872
 873     if (!priv->is_child_up) {
 874         DBG ("no child process is running - closing pam session");
 875         _clear_session (session);
 876         if (session->priv->can_emit_signal)
 877             g_signal_emit (session, signals[SIG_SESSION_TERMINATED], 0);
 878         return;
 879     }
 880
 881     if (killpg (getpgid (priv->child_pid), SIGHUP) < 0)
 882         WARN ("kill(%u, SIGHUP): %s",
 883               getpgid (priv->child_pid),
 884               strerror(errno));
 885     priv->last_sig = SIGHUP;
 886     priv->timer_id = g_timeout_add_seconds (
 887             tlm_config_get_uint (priv->config, TLM_CONFIG_GENERAL,
 888                     TLM_CONFIG_GENERAL_TERMINATE_TIMEOUT, 3),
 889             _terminate_timeout,
 890             session);
 891 }
 892
 893 void
 894 tlm_session_reset_tty (TlmSession *session)
 895 {
 896     TlmSessionPrivate *priv = TLM_SESSION_PRIV(session);
 897
 898     if (fchown (0, priv->tty_uid, priv->tty_gid))
 899         WARN ("Changing TTY access rights failed");
 900     if (tcflush (0, TCIOFLUSH) ||
 901         tcflush (1, TCIOFLUSH) ||
 902         tcflush (2, TCIOFLUSH))
 903         WARN ("Flushing stdio failed");
 904     pid_t pgid = getpgid (getpid ());
 905     if (tcsetpgrp (0, pgid) || tcsetpgrp (1, pgid) || tcsetpgrp (2, pgid))
 906         WARN ("Change TTY controlling process failed");
 907     if (tcsetattr (0, TCSANOW, &priv->stdin_state) ||
 908         tcsetattr (1, TCSANOW, &priv->stdout_state) ||
 909         tcsetattr (2, TCSANOW, &priv->stderr_state))
 910         WARN ("Restoring TTY settings failed");
 911 }
 912