src/login/logind-session.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2011 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <errno.h>
  23 #include <fcntl.h>
  24 #include <linux/kd.h>
  25 #include <linux/vt.h>
  26 #include <signal.h>
  27 #include <string.h>
  28 #include <sys/ioctl.h>
  29 #include <unistd.h>
  30
  31 #include "sd-messages.h"
  32
  33 #include "audit.h"
  34 #include "bus-error.h"
  35 #include "bus-util.h"
  36 #include "escape.h"
  37 #include "fd-util.h"
  38 #include "fd-util.h"
  39 #include "fileio.h"
  40 #include "formats-util.h"
  41 #include "io-util.h"
  42 #include "logind-session.h"
  43 #include "mkdir.h"
  44 #include "path-util.h"
  45 #include "terminal-util.h"
  46 #include "user-util.h"
  47 #include "util.h"
  48
  49 #define RELEASE_USEC (20*USEC_PER_SEC)
  50
  51 static void session_remove_fifo(Session *s);
  52
  53 Session* session_new(Manager *m, const char *id) {
  54         Session *s;
  55
  56         assert(m);
  57         assert(id);
  58         assert(session_id_valid(id));
  59
  60         s = new0(Session, 1);
  61         if (!s)
  62                 return NULL;
  63
  64         s->state_file = strappend("/run/systemd/sessions/", id);
  65         if (!s->state_file) {
  66                 free(s);
  67                 return NULL;
  68         }
  69
  70         s->devices = hashmap_new(&devt_hash_ops);
  71         if (!s->devices) {
  72                 free(s->state_file);
  73                 free(s);
  74                 return NULL;
  75         }
  76
  77         s->id = basename(s->state_file);
  78
  79         if (hashmap_put(m->sessions, s->id, s) < 0) {
  80                 hashmap_free(s->devices);
  81                 free(s->state_file);
  82                 free(s);
  83                 return NULL;
  84         }
  85
  86         s->manager = m;
  87         s->fifo_fd = -1;
  88         s->vtfd = -1;
  89
  90         return s;
  91 }
  92
  93 void session_free(Session *s) {
  94         SessionDevice *sd;
  95
  96         assert(s);
  97
  98         if (s->in_gc_queue)
  99                 LIST_REMOVE(gc_queue, s->manager->session_gc_queue, s);
 100
 101         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 102
 103         session_remove_fifo(s);
 104
 105         session_drop_controller(s);
 106
 107         while ((sd = hashmap_first(s->devices)))
 108                 session_device_free(sd);
 109
 110         hashmap_free(s->devices);
 111
 112         if (s->user) {
 113                 LIST_REMOVE(sessions_by_user, s->user->sessions, s);
 114
 115                 if (s->user->display == s)
 116                         s->user->display = NULL;
 117         }
 118
 119         if (s->seat) {
 120                 if (s->seat->active == s)
 121                         s->seat->active = NULL;
 122                 if (s->seat->pending_switch == s)
 123                         s->seat->pending_switch = NULL;
 124
 125                 seat_evict_position(s->seat, s);
 126                 LIST_REMOVE(sessions_by_seat, s->seat->sessions, s);
 127         }
 128
 129         if (s->scope) {
 130                 hashmap_remove(s->manager->session_units, s->scope);
 131                 free(s->scope);
 132         }
 133
 134         free(s->scope_job);
 135
 136         sd_bus_message_unref(s->create_message);
 137
 138         free(s->tty);
 139         free(s->display);
 140         free(s->remote_host);
 141         free(s->remote_user);
 142         free(s->service);
 143         free(s->desktop);
 144
 145         hashmap_remove(s->manager->sessions, s->id);
 146
 147         free(s->state_file);
 148         free(s);
 149 }
 150
 151 void session_set_user(Session *s, User *u) {
 152         assert(s);
 153         assert(!s->user);
 154
 155         s->user = u;
 156         LIST_PREPEND(sessions_by_user, u->sessions, s);
 157 }
 158
 159 int session_save(Session *s) {
 160         _cleanup_free_ char *temp_path = NULL;
 161         _cleanup_fclose_ FILE *f = NULL;
 162         int r = 0;
 163
 164         assert(s);
 165
 166         if (!s->user)
 167                 return -ESTALE;
 168
 169         if (!s->started)
 170                 return 0;
 171
 172         r = mkdir_safe_label("/run/systemd/sessions", 0755, 0, 0);
 173         if (r < 0)
 174                 goto fail;
 175
 176         r = fopen_temporary(s->state_file, &f, &temp_path);
 177         if (r < 0)
 178                 goto fail;
 179
 180         assert(s->user);
 181
 182         fchmod(fileno(f), 0644);
 183
 184         fprintf(f,
 185                 "# This is private data. Do not parse.\n"
 186                 "UID="UID_FMT"\n"
 187                 "USER=%s\n"
 188                 "ACTIVE=%i\n"
 189                 "STATE=%s\n"
 190                 "REMOTE=%i\n",
 191                 s->user->uid,
 192                 s->user->name,
 193                 session_is_active(s),
 194                 session_state_to_string(session_get_state(s)),
 195                 s->remote);
 196
 197         if (s->type >= 0)
 198                 fprintf(f, "TYPE=%s\n", session_type_to_string(s->type));
 199
 200         if (s->class >= 0)
 201                 fprintf(f, "CLASS=%s\n", session_class_to_string(s->class));
 202
 203         if (s->scope)
 204                 fprintf(f, "SCOPE=%s\n", s->scope);
 205         if (s->scope_job)
 206                 fprintf(f, "SCOPE_JOB=%s\n", s->scope_job);
 207
 208         if (s->fifo_path)
 209                 fprintf(f, "FIFO=%s\n", s->fifo_path);
 210
 211         if (s->seat)
 212                 fprintf(f, "SEAT=%s\n", s->seat->id);
 213
 214         if (s->tty)
 215                 fprintf(f, "TTY=%s\n", s->tty);
 216
 217         if (s->display)
 218                 fprintf(f, "DISPLAY=%s\n", s->display);
 219
 220         if (s->remote_host) {
 221                 _cleanup_free_ char *escaped;
 222
 223                 escaped = cescape(s->remote_host);
 224                 if (!escaped) {
 225                         r = -ENOMEM;
 226                         goto fail;
 227                 }
 228
 229                 fprintf(f, "REMOTE_HOST=%s\n", escaped);
 230         }
 231
 232         if (s->remote_user) {
 233                 _cleanup_free_ char *escaped;
 234
 235                 escaped = cescape(s->remote_user);
 236                 if (!escaped) {
 237                         r = -ENOMEM;
 238                         goto fail;
 239                 }
 240
 241                 fprintf(f, "REMOTE_USER=%s\n", escaped);
 242         }
 243
 244         if (s->service) {
 245                 _cleanup_free_ char *escaped;
 246
 247                 escaped = cescape(s->service);
 248                 if (!escaped) {
 249                         r = -ENOMEM;
 250                         goto fail;
 251                 }
 252
 253                 fprintf(f, "SERVICE=%s\n", escaped);
 254         }
 255
 256         if (s->desktop) {
 257                 _cleanup_free_ char *escaped;
 258
 259
 260                 escaped = cescape(s->desktop);
 261                 if (!escaped) {
 262                         r = -ENOMEM;
 263                         goto fail;
 264                 }
 265
 266                 fprintf(f, "DESKTOP=%s\n", escaped);
 267         }
 268
 269         if (s->seat && seat_has_vts(s->seat))
 270                 fprintf(f, "VTNR=%u\n", s->vtnr);
 271
 272         if (!s->vtnr)
 273                 fprintf(f, "POSITION=%u\n", s->position);
 274
 275         if (s->leader > 0)
 276                 fprintf(f, "LEADER="PID_FMT"\n", s->leader);
 277
 278         if (s->audit_id > 0)
 279                 fprintf(f, "AUDIT=%"PRIu32"\n", s->audit_id);
 280
 281         if (dual_timestamp_is_set(&s->timestamp))
 282                 fprintf(f,
 283                         "REALTIME="USEC_FMT"\n"
 284                         "MONOTONIC="USEC_FMT"\n",
 285                         s->timestamp.realtime,
 286                         s->timestamp.monotonic);
 287
 288         if (s->controller)
 289                 fprintf(f, "CONTROLLER=%s\n", s->controller);
 290
 291         r = fflush_and_check(f);
 292         if (r < 0)
 293                 goto fail;
 294
 295         if (rename(temp_path, s->state_file) < 0) {
 296                 r = -errno;
 297                 goto fail;
 298         }
 299
 300         return 0;
 301
 302 fail:
 303         (void) unlink(s->state_file);
 304
 305         if (temp_path)
 306                 (void) unlink(temp_path);
 307
 308         return log_error_errno(r, "Failed to save session data %s: %m", s->state_file);
 309 }
 310
 311
 312 int session_load(Session *s) {
 313         _cleanup_free_ char *remote = NULL,
 314                 *seat = NULL,
 315                 *vtnr = NULL,
 316                 *state = NULL,
 317                 *position = NULL,
 318                 *leader = NULL,
 319                 *type = NULL,
 320                 *class = NULL,
 321                 *uid = NULL,
 322                 *realtime = NULL,
 323                 *monotonic = NULL,
 324                 *controller = NULL;
 325
 326         int k, r;
 327
 328         assert(s);
 329
 330         r = parse_env_file(s->state_file, NEWLINE,
 331                            "REMOTE",         &remote,
 332                            "SCOPE",          &s->scope,
 333                            "SCOPE_JOB",      &s->scope_job,
 334                            "FIFO",           &s->fifo_path,
 335                            "SEAT",           &seat,
 336                            "TTY",            &s->tty,
 337                            "DISPLAY",        &s->display,
 338                            "REMOTE_HOST",    &s->remote_host,
 339                            "REMOTE_USER",    &s->remote_user,
 340                            "SERVICE",        &s->service,
 341                            "DESKTOP",        &s->desktop,
 342                            "VTNR",           &vtnr,
 343                            "STATE",          &state,
 344                            "POSITION",       &position,
 345                            "LEADER",         &leader,
 346                            "TYPE",           &type,
 347                            "CLASS",          &class,
 348                            "UID",            &uid,
 349                            "REALTIME",       &realtime,
 350                            "MONOTONIC",      &monotonic,
 351                            "CONTROLLER",     &controller,
 352                            NULL);
 353
 354         if (r < 0)
 355                 return log_error_errno(r, "Failed to read %s: %m", s->state_file);
 356
 357         if (!s->user) {
 358                 uid_t u;
 359                 User *user;
 360
 361                 if (!uid) {
 362                         log_error("UID not specified for session %s", s->id);
 363                         return -ENOENT;
 364                 }
 365
 366                 r = parse_uid(uid, &u);
 367                 if (r < 0)  {
 368                         log_error("Failed to parse UID value %s for session %s.", uid, s->id);
 369                         return r;
 370                 }
 371
 372                 user = hashmap_get(s->manager->users, UID_TO_PTR(u));
 373                 if (!user) {
 374                         log_error("User of session %s not known.", s->id);
 375                         return -ENOENT;
 376                 }
 377
 378                 session_set_user(s, user);
 379         }
 380
 381         if (remote) {
 382                 k = parse_boolean(remote);
 383                 if (k >= 0)
 384                         s->remote = k;
 385         }
 386
 387         if (vtnr)
 388                 safe_atou(vtnr, &s->vtnr);
 389
 390         if (seat && !s->seat) {
 391                 Seat *o;
 392
 393                 o = hashmap_get(s->manager->seats, seat);
 394                 if (o)
 395                         r = seat_attach_session(o, s);
 396                 if (!o || r < 0)
 397                         log_error("Cannot attach session %s to seat %s", s->id, seat);
 398         }
 399
 400         if (!s->seat || !seat_has_vts(s->seat))
 401                 s->vtnr = 0;
 402
 403         if (position && s->seat) {
 404                 unsigned int npos;
 405
 406                 safe_atou(position, &npos);
 407                 seat_claim_position(s->seat, s, npos);
 408         }
 409
 410         if (leader) {
 411                 k = parse_pid(leader, &s->leader);
 412                 if (k >= 0)
 413                         audit_session_from_pid(s->leader, &s->audit_id);
 414         }
 415
 416         if (type) {
 417                 SessionType t;
 418
 419                 t = session_type_from_string(type);
 420                 if (t >= 0)
 421                         s->type = t;
 422         }
 423
 424         if (class) {
 425                 SessionClass c;
 426
 427                 c = session_class_from_string(class);
 428                 if (c >= 0)
 429                         s->class = c;
 430         }
 431
 432         if (state && streq(state, "closing"))
 433                 s->stopping = true;
 434
 435         if (s->fifo_path) {
 436                 int fd;
 437
 438                 /* If we open an unopened pipe for reading we will not
 439                    get an EOF. to trigger an EOF we hence open it for
 440                    writing, but close it right away which then will
 441                    trigger the EOF. This will happen immediately if no
 442                    other process has the FIFO open for writing, i. e.
 443                    when the session died before logind (re)started. */
 444
 445                 fd = session_create_fifo(s);
 446                 safe_close(fd);
 447         }
 448
 449         if (realtime) {
 450                 unsigned long long l;
 451                 if (sscanf(realtime, "%llu", &l) > 0)
 452                         s->timestamp.realtime = l;
 453         }
 454
 455         if (monotonic) {
 456                 unsigned long long l;
 457                 if (sscanf(monotonic, "%llu", &l) > 0)
 458                         s->timestamp.monotonic = l;
 459         }
 460
 461         if (controller) {
 462                 if (bus_name_has_owner(s->manager->bus, controller, NULL) > 0)
 463                         session_set_controller(s, controller, false);
 464                 else
 465                         session_restore_vt(s);
 466         }
 467
 468         return r;
 469 }
 470
 471 int session_activate(Session *s) {
 472         unsigned int num_pending;
 473
 474         assert(s);
 475         assert(s->user);
 476
 477         if (!s->seat)
 478                 return -EOPNOTSUPP;
 479
 480         if (s->seat->active == s)
 481                 return 0;
 482
 483         /* on seats with VTs, we let VTs manage session-switching */
 484         if (seat_has_vts(s->seat)) {
 485                 if (!s->vtnr)
 486                         return -EOPNOTSUPP;
 487
 488                 return chvt(s->vtnr);
 489         }
 490
 491         /* On seats without VTs, we implement session-switching in logind. We
 492          * try to pause all session-devices and wait until the session
 493          * controller acknowledged them. Once all devices are asleep, we simply
 494          * switch the active session and be done.
 495          * We save the session we want to switch to in seat->pending_switch and
 496          * seat_complete_switch() will perform the final switch. */
 497
 498         s->seat->pending_switch = s;
 499
 500         /* if no devices are running, immediately perform the session switch */
 501         num_pending = session_device_try_pause_all(s);
 502         if (!num_pending)
 503                 seat_complete_switch(s->seat);
 504
 505         return 0;
 506 }
 507
 508 static int session_start_scope(Session *s) {
 509         int r;
 510
 511         assert(s);
 512         assert(s->user);
 513         assert(s->user->slice);
 514
 515         if (!s->scope) {
 516                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 517                 _cleanup_free_ char *description = NULL;
 518                 char *scope, *job = NULL;
 519
 520                 description = strjoin("Session ", s->id, " of user ", s->user->name, NULL);
 521                 if (!description)
 522                         return log_oom();
 523
 524                 scope = strjoin("session-", s->id, ".scope", NULL);
 525                 if (!scope)
 526                         return log_oom();
 527
 528                 r = manager_start_scope(s->manager, scope, s->leader, s->user->slice, description, "systemd-logind.service", "systemd-user-sessions.service", &error, &job);
 529                 if (r < 0) {
 530                         log_error("Failed to start session scope %s: %s %s",
 531                                   scope, bus_error_message(&error, r), error.name);
 532                         free(scope);
 533                         return r;
 534                 } else {
 535                         s->scope = scope;
 536
 537                         free(s->scope_job);
 538                         s->scope_job = job;
 539                 }
 540         }
 541
 542         if (s->scope)
 543                 hashmap_put(s->manager->session_units, s->scope, s);
 544
 545         return 0;
 546 }
 547
 548 int session_start(Session *s) {
 549         int r;
 550
 551         assert(s);
 552
 553         if (!s->user)
 554                 return -ESTALE;
 555
 556         if (s->started)
 557                 return 0;
 558
 559         r = user_start(s->user);
 560         if (r < 0)
 561                 return r;
 562
 563         /* Create cgroup */
 564         r = session_start_scope(s);
 565         if (r < 0)
 566                 return r;
 567
 568         log_struct(s->class == SESSION_BACKGROUND ? LOG_DEBUG : LOG_INFO,
 569                    LOG_MESSAGE_ID(SD_MESSAGE_SESSION_START),
 570                    "SESSION_ID=%s", s->id,
 571                    "USER_ID=%s", s->user->name,
 572                    "LEADER="PID_FMT, s->leader,
 573                    LOG_MESSAGE("New session %s of user %s.", s->id, s->user->name),
 574                    NULL);
 575
 576         if (!dual_timestamp_is_set(&s->timestamp))
 577                 dual_timestamp_get(&s->timestamp);
 578
 579         if (s->seat)
 580                 seat_read_active_vt(s->seat);
 581
 582         s->started = true;
 583
 584         user_elect_display(s->user);
 585
 586         /* Save data */
 587         session_save(s);
 588         user_save(s->user);
 589         if (s->seat)
 590                 seat_save(s->seat);
 591
 592         /* Send signals */
 593         session_send_signal(s, true);
 594         user_send_changed(s->user, "Sessions", "Display", NULL);
 595         if (s->seat) {
 596                 if (s->seat->active == s)
 597                         seat_send_changed(s->seat, "Sessions", "ActiveSession", NULL);
 598                 else
 599                         seat_send_changed(s->seat, "Sessions", NULL);
 600         }
 601
 602         return 0;
 603 }
 604
 605 static int session_stop_scope(Session *s, bool force) {
 606         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 607         char *job = NULL;
 608         int r;
 609
 610         assert(s);
 611
 612         if (!s->scope)
 613                 return 0;
 614
 615         if (force || manager_shall_kill(s->manager, s->user->name)) {
 616                 r = manager_stop_unit(s->manager, s->scope, &error, &job);
 617                 if (r < 0) {
 618                         log_error("Failed to stop session scope: %s", bus_error_message(&error, r));
 619                         return r;
 620                 }
 621
 622                 free(s->scope_job);
 623                 s->scope_job = job;
 624         } else {
 625                 r = manager_abandon_scope(s->manager, s->scope, &error);
 626                 if (r < 0) {
 627                         log_error("Failed to abandon session scope: %s", bus_error_message(&error, r));
 628                         return r;
 629                 }
 630         }
 631
 632         return 0;
 633 }
 634
 635 int session_stop(Session *s, bool force) {
 636         int r;
 637
 638         assert(s);
 639
 640         if (!s->user)
 641                 return -ESTALE;
 642
 643         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 644
 645         if (s->seat)
 646                 seat_evict_position(s->seat, s);
 647
 648         /* We are going down, don't care about FIFOs anymore */
 649         session_remove_fifo(s);
 650
 651         /* Kill cgroup */
 652         r = session_stop_scope(s, force);
 653
 654         s->stopping = true;
 655
 656         user_elect_display(s->user);
 657
 658         session_save(s);
 659         user_save(s->user);
 660
 661         return r;
 662 }
 663
 664 int session_finalize(Session *s) {
 665         SessionDevice *sd;
 666
 667         assert(s);
 668
 669         if (!s->user)
 670                 return -ESTALE;
 671
 672         if (s->started)
 673                 log_struct(s->class == SESSION_BACKGROUND ? LOG_DEBUG : LOG_INFO,
 674                            LOG_MESSAGE_ID(SD_MESSAGE_SESSION_STOP),
 675                            "SESSION_ID=%s", s->id,
 676                            "USER_ID=%s", s->user->name,
 677                            "LEADER="PID_FMT, s->leader,
 678                            LOG_MESSAGE("Removed session %s.", s->id),
 679                            NULL);
 680
 681         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 682
 683         if (s->seat)
 684                 seat_evict_position(s->seat, s);
 685
 686         /* Kill session devices */
 687         while ((sd = hashmap_first(s->devices)))
 688                 session_device_free(sd);
 689
 690         (void) unlink(s->state_file);
 691         session_add_to_gc_queue(s);
 692         user_add_to_gc_queue(s->user);
 693
 694         if (s->started) {
 695                 session_send_signal(s, false);
 696                 s->started = false;
 697         }
 698
 699         if (s->seat) {
 700                 if (s->seat->active == s)
 701                         seat_set_active(s->seat, NULL);
 702
 703                 seat_save(s->seat);
 704                 seat_send_changed(s->seat, "Sessions", NULL);
 705         }
 706
 707         user_save(s->user);
 708         user_send_changed(s->user, "Sessions", "Display", NULL);
 709
 710         return 0;
 711 }
 712
 713 static int release_timeout_callback(sd_event_source *es, uint64_t usec, void *userdata) {
 714         Session *s = userdata;
 715
 716         assert(es);
 717         assert(s);
 718
 719         session_stop(s, false);
 720         return 0;
 721 }
 722
 723 int session_release(Session *s) {
 724         assert(s);
 725
 726         if (!s->started || s->stopping)
 727                 return 0;
 728
 729         if (s->timer_event_source)
 730                 return 0;
 731
 732         return sd_event_add_time(s->manager->event,
 733                                  &s->timer_event_source,
 734                                  CLOCK_MONOTONIC,
 735                                  now(CLOCK_MONOTONIC) + RELEASE_USEC, 0,
 736                                  release_timeout_callback, s);
 737 }
 738
 739 bool session_is_active(Session *s) {
 740         assert(s);
 741
 742         if (!s->seat)
 743                 return true;
 744
 745         return s->seat->active == s;
 746 }
 747
 748 static int get_tty_atime(const char *tty, usec_t *atime) {
 749         _cleanup_free_ char *p = NULL;
 750         struct stat st;
 751
 752         assert(tty);
 753         assert(atime);
 754
 755         if (!path_is_absolute(tty)) {
 756                 p = strappend("/dev/", tty);
 757                 if (!p)
 758                         return -ENOMEM;
 759
 760                 tty = p;
 761         } else if (!path_startswith(tty, "/dev/"))
 762                 return -ENOENT;
 763
 764         if (lstat(tty, &st) < 0)
 765                 return -errno;
 766
 767         *atime = timespec_load(&st.st_atim);
 768         return 0;
 769 }
 770
 771 static int get_process_ctty_atime(pid_t pid, usec_t *atime) {
 772         _cleanup_free_ char *p = NULL;
 773         int r;
 774
 775         assert(pid > 0);
 776         assert(atime);
 777
 778         r = get_ctty(pid, NULL, &p);
 779         if (r < 0)
 780                 return r;
 781
 782         return get_tty_atime(p, atime);
 783 }
 784
 785 int session_get_idle_hint(Session *s, dual_timestamp *t) {
 786         usec_t atime = 0, n;
 787         int r;
 788
 789         assert(s);
 790
 791         /* Explicit idle hint is set */
 792         if (s->idle_hint) {
 793                 if (t)
 794                         *t = s->idle_hint_timestamp;
 795
 796                 return s->idle_hint;
 797         }
 798
 799         /* Graphical sessions should really implement a real
 800          * idle hint logic */
 801         if (s->display)
 802                 goto dont_know;
 803
 804         /* For sessions with an explicitly configured tty, let's check
 805          * its atime */
 806         if (s->tty) {
 807                 r = get_tty_atime(s->tty, &atime);
 808                 if (r >= 0)
 809                         goto found_atime;
 810         }
 811
 812         /* For sessions with a leader but no explicitly configured
 813          * tty, let's check the controlling tty of the leader */
 814         if (s->leader > 0) {
 815                 r = get_process_ctty_atime(s->leader, &atime);
 816                 if (r >= 0)
 817                         goto found_atime;
 818         }
 819
 820 dont_know:
 821         if (t)
 822                 *t = s->idle_hint_timestamp;
 823
 824         return 0;
 825
 826 found_atime:
 827         if (t)
 828                 dual_timestamp_from_realtime(t, atime);
 829
 830         n = now(CLOCK_REALTIME);
 831
 832         if (s->manager->idle_action_usec <= 0)
 833                 return 0;
 834
 835         return atime + s->manager->idle_action_usec <= n;
 836 }
 837
 838 void session_set_idle_hint(Session *s, bool b) {
 839         assert(s);
 840
 841         if (s->idle_hint == b)
 842                 return;
 843
 844         s->idle_hint = b;
 845         dual_timestamp_get(&s->idle_hint_timestamp);
 846
 847         session_send_changed(s, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
 848
 849         if (s->seat)
 850                 seat_send_changed(s->seat, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
 851
 852         user_send_changed(s->user, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
 853         manager_send_changed(s->manager, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
 854 }
 855
 856 static int session_dispatch_fifo(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
 857         Session *s = userdata;
 858
 859         assert(s);
 860         assert(s->fifo_fd == fd);
 861
 862         /* EOF on the FIFO means the session died abnormally. */
 863
 864         session_remove_fifo(s);
 865         session_stop(s, false);
 866
 867         return 1;
 868 }
 869
 870 int session_create_fifo(Session *s) {
 871         int r;
 872
 873         assert(s);
 874
 875         /* Create FIFO */
 876         if (!s->fifo_path) {
 877                 r = mkdir_safe_label("/run/systemd/sessions", 0755, 0, 0);
 878                 if (r < 0)
 879                         return r;
 880
 881                 if (asprintf(&s->fifo_path, "/run/systemd/sessions/%s.ref", s->id) < 0)
 882                         return -ENOMEM;
 883
 884                 if (mkfifo(s->fifo_path, 0600) < 0 && errno != EEXIST)
 885                         return -errno;
 886         }
 887
 888         /* Open reading side */
 889         if (s->fifo_fd < 0) {
 890                 s->fifo_fd = open(s->fifo_path, O_RDONLY|O_CLOEXEC|O_NDELAY);
 891                 if (s->fifo_fd < 0)
 892                         return -errno;
 893
 894         }
 895
 896         if (!s->fifo_event_source) {
 897                 r = sd_event_add_io(s->manager->event, &s->fifo_event_source, s->fifo_fd, 0, session_dispatch_fifo, s);
 898                 if (r < 0)
 899                         return r;
 900
 901                 r = sd_event_source_set_priority(s->fifo_event_source, SD_EVENT_PRIORITY_IDLE);
 902                 if (r < 0)
 903                         return r;
 904         }
 905
 906         /* Open writing side */
 907         r = open(s->fifo_path, O_WRONLY|O_CLOEXEC|O_NDELAY);
 908         if (r < 0)
 909                 return -errno;
 910
 911         return r;
 912 }
 913
 914 static void session_remove_fifo(Session *s) {
 915         assert(s);
 916
 917         s->fifo_event_source = sd_event_source_unref(s->fifo_event_source);
 918         s->fifo_fd = safe_close(s->fifo_fd);
 919
 920         if (s->fifo_path) {
 921                 unlink(s->fifo_path);
 922                 s->fifo_path = mfree(s->fifo_path);
 923         }
 924 }
 925
 926 bool session_check_gc(Session *s, bool drop_not_started) {
 927         assert(s);
 928
 929         if (drop_not_started && !s->started)
 930                 return false;
 931
 932         if (!s->user)
 933                 return false;
 934
 935         if (s->fifo_fd >= 0) {
 936                 if (pipe_eof(s->fifo_fd) <= 0)
 937                         return true;
 938         }
 939
 940         if (s->scope_job && manager_job_is_active(s->manager, s->scope_job))
 941                 return true;
 942
 943         if (s->scope && manager_unit_is_active(s->manager, s->scope))
 944                 return true;
 945
 946         return false;
 947 }
 948
 949 void session_add_to_gc_queue(Session *s) {
 950         assert(s);
 951
 952         if (s->in_gc_queue)
 953                 return;
 954
 955         LIST_PREPEND(gc_queue, s->manager->session_gc_queue, s);
 956         s->in_gc_queue = true;
 957 }
 958
 959 SessionState session_get_state(Session *s) {
 960         assert(s);
 961
 962         /* always check closing first */
 963         if (s->stopping || s->timer_event_source)
 964                 return SESSION_CLOSING;
 965
 966         if (s->scope_job || s->fifo_fd < 0)
 967                 return SESSION_OPENING;
 968
 969         if (session_is_active(s))
 970                 return SESSION_ACTIVE;
 971
 972         return SESSION_ONLINE;
 973 }
 974
 975 int session_kill(Session *s, KillWho who, int signo) {
 976         assert(s);
 977
 978         if (!s->scope)
 979                 return -ESRCH;
 980
 981         return manager_kill_unit(s->manager, s->scope, who, signo, NULL);
 982 }
 983
 984 static int session_open_vt(Session *s) {
 985         char path[sizeof("/dev/tty") + DECIMAL_STR_MAX(s->vtnr)];
 986
 987         if (s->vtnr < 1)
 988                 return -ENODEV;
 989
 990         if (s->vtfd >= 0)
 991                 return s->vtfd;
 992
 993         sprintf(path, "/dev/tty%u", s->vtnr);
 994         s->vtfd = open_terminal(path, O_RDWR | O_CLOEXEC | O_NONBLOCK | O_NOCTTY);
 995         if (s->vtfd < 0)
 996                 return log_error_errno(errno, "cannot open VT %s of session %s: %m", path, s->id);
 997
 998         return s->vtfd;
 999 }
1000
1001 int session_prepare_vt(Session *s) {
1002         int vt, r;
1003         struct vt_mode mode = { 0 };
1004
1005         if (s->vtnr < 1)
1006                 return 0;
1007
1008         vt = session_open_vt(s);
1009         if (vt < 0)
1010                 return vt;
1011
1012         r = fchown(vt, s->user->uid, -1);
1013         if (r < 0) {
1014                 r = log_error_errno(errno,
1015                                     "Cannot change owner of /dev/tty%u: %m",
1016                                     s->vtnr);
1017                 goto error;
1018         }
1019
1020         r = ioctl(vt, KDSKBMODE, K_OFF);
1021         if (r < 0) {
1022                 r = log_error_errno(errno,
1023                                     "Cannot set K_OFF on /dev/tty%u: %m",
1024                                     s->vtnr);
1025                 goto error;
1026         }
1027
1028         r = ioctl(vt, KDSETMODE, KD_GRAPHICS);
1029         if (r < 0) {
1030                 r = log_error_errno(errno,
1031                                     "Cannot set KD_GRAPHICS on /dev/tty%u: %m",
1032                                     s->vtnr);
1033                 goto error;
1034         }
1035
1036         /* Oh, thanks to the VT layer, VT_AUTO does not work with KD_GRAPHICS.
1037          * So we need a dummy handler here which just acknowledges *all* VT
1038          * switch requests. */
1039         mode.mode = VT_PROCESS;
1040         mode.relsig = SIGRTMIN;
1041         mode.acqsig = SIGRTMIN + 1;
1042         r = ioctl(vt, VT_SETMODE, &mode);
1043         if (r < 0) {
1044                 r = log_error_errno(errno,
1045                                     "Cannot set VT_PROCESS on /dev/tty%u: %m",
1046                                     s->vtnr);
1047                 goto error;
1048         }
1049
1050         return 0;
1051
1052 error:
1053         session_restore_vt(s);
1054         return r;
1055 }
1056
1057 void session_restore_vt(Session *s) {
1058
1059         static const struct vt_mode mode = {
1060                 .mode = VT_AUTO,
1061         };
1062
1063         _cleanup_free_ char *utf8 = NULL;
1064         int vt, kb, old_fd;
1065
1066         /* We need to get a fresh handle to the virtual terminal,
1067          * since the old file-descriptor is potentially in a hung-up
1068          * state after the controlling process exited; we do a
1069          * little dance to avoid having the terminal be available
1070          * for reuse before we've cleaned it up.
1071          */
1072         old_fd = s->vtfd;
1073         s->vtfd = -1;
1074
1075         vt = session_open_vt(s);
1076         safe_close(old_fd);
1077
1078         if (vt < 0)
1079                 return;
1080
1081         (void) ioctl(vt, KDSETMODE, KD_TEXT);
1082
1083         if (read_one_line_file("/sys/module/vt/parameters/default_utf8", &utf8) >= 0 && *utf8 == '1')
1084                 kb = K_UNICODE;
1085         else
1086                 kb = K_XLATE;
1087
1088         (void) ioctl(vt, KDSKBMODE, kb);
1089
1090         (void) ioctl(vt, VT_SETMODE, &mode);
1091         (void) fchown(vt, 0, (gid_t) -1);
1092
1093         s->vtfd = safe_close(s->vtfd);
1094 }
1095
1096 void session_leave_vt(Session *s) {
1097         int r;
1098
1099         assert(s);
1100
1101         /* This is called whenever we get a VT-switch signal from the kernel.
1102          * We acknowledge all of them unconditionally. Note that session are
1103          * free to overwrite those handlers and we only register them for
1104          * sessions with controllers. Legacy sessions are not affected.
1105          * However, if we switch from a non-legacy to a legacy session, we must
1106          * make sure to pause all device before acknowledging the switch. We
1107          * process the real switch only after we are notified via sysfs, so the
1108          * legacy session might have already started using the devices. If we
1109          * don't pause the devices before the switch, we might confuse the
1110          * session we switch to. */
1111
1112         if (s->vtfd < 0)
1113                 return;
1114
1115         session_device_pause_all(s);
1116         r = ioctl(s->vtfd, VT_RELDISP, 1);
1117         if (r < 0)
1118                 log_debug_errno(errno, "Cannot release VT of session %s: %m", s->id);
1119 }
1120
1121 bool session_is_controller(Session *s, const char *sender) {
1122         assert(s);
1123
1124         return streq_ptr(s->controller, sender);
1125 }
1126
1127 static void session_release_controller(Session *s, bool notify) {
1128         _cleanup_free_ char *name = NULL;
1129         SessionDevice *sd;
1130
1131         if (!s->controller)
1132                 return;
1133
1134         name = s->controller;
1135
1136         /* By resetting the controller before releasing the devices, we won't
1137          * send notification signals. This avoids sending useless notifications
1138          * if the controller is released on disconnects. */
1139         if (!notify)
1140                 s->controller = NULL;
1141
1142         while ((sd = hashmap_first(s->devices)))
1143                 session_device_free(sd);
1144
1145         s->controller = NULL;
1146         s->track = sd_bus_track_unref(s->track);
1147 }
1148
1149 static int on_bus_track(sd_bus_track *track, void *userdata) {
1150         Session *s = userdata;
1151
1152         assert(track);
1153         assert(s);
1154
1155         session_drop_controller(s);
1156
1157         return 0;
1158 }
1159
1160 int session_set_controller(Session *s, const char *sender, bool force) {
1161         _cleanup_free_ char *name = NULL;
1162         int r;
1163
1164         assert(s);
1165         assert(sender);
1166
1167         if (session_is_controller(s, sender))
1168                 return 0;
1169         if (s->controller && !force)
1170                 return -EBUSY;
1171
1172         name = strdup(sender);
1173         if (!name)
1174                 return -ENOMEM;
1175
1176         s->track = sd_bus_track_unref(s->track);
1177         r = sd_bus_track_new(s->manager->bus, &s->track, on_bus_track, s);
1178         if (r < 0)
1179                 return r;
1180
1181         r = sd_bus_track_add_name(s->track, name);
1182         if (r < 0)
1183                 return r;
1184
1185         /* When setting a session controller, we forcibly mute the VT and set
1186          * it into graphics-mode. Applications can override that by changing
1187          * VT state after calling TakeControl(). However, this serves as a good
1188          * default and well-behaving controllers can now ignore VTs entirely.
1189          * Note that we reset the VT on ReleaseControl() and if the controller
1190          * exits.
1191          * If logind crashes/restarts, we restore the controller during restart
1192          * or reset the VT in case it crashed/exited, too. */
1193         r = session_prepare_vt(s);
1194         if (r < 0) {
1195                 s->track = sd_bus_track_unref(s->track);
1196                 return r;
1197         }
1198
1199         session_release_controller(s, true);
1200         s->controller = name;
1201         name = NULL;
1202         session_save(s);
1203
1204         return 0;
1205 }
1206
1207 void session_drop_controller(Session *s) {
1208         assert(s);
1209
1210         if (!s->controller)
1211                 return;
1212
1213         s->track = sd_bus_track_unref(s->track);
1214         session_release_controller(s, false);
1215         session_save(s);
1216         session_restore_vt(s);
1217 }
1218
1219 static const char* const session_state_table[_SESSION_STATE_MAX] = {
1220         [SESSION_OPENING] = "opening",
1221         [SESSION_ONLINE] = "online",
1222         [SESSION_ACTIVE] = "active",
1223         [SESSION_CLOSING] = "closing"
1224 };
1225
1226 DEFINE_STRING_TABLE_LOOKUP(session_state, SessionState);
1227
1228 static const char* const session_type_table[_SESSION_TYPE_MAX] = {
1229         [SESSION_UNSPECIFIED] = "unspecified",
1230         [SESSION_TTY] = "tty",
1231         [SESSION_X11] = "x11",
1232         [SESSION_WAYLAND] = "wayland",
1233         [SESSION_MIR] = "mir",
1234         [SESSION_WEB] = "web",
1235 };
1236
1237 DEFINE_STRING_TABLE_LOOKUP(session_type, SessionType);
1238
1239 static const char* const session_class_table[_SESSION_CLASS_MAX] = {
1240         [SESSION_USER] = "user",
1241         [SESSION_GREETER] = "greeter",
1242         [SESSION_LOCK_SCREEN] = "lock-screen",
1243         [SESSION_BACKGROUND] = "background"
1244 };
1245
1246 DEFINE_STRING_TABLE_LOOKUP(session_class, SessionClass);
1247
1248 static const char* const kill_who_table[_KILL_WHO_MAX] = {
1249         [KILL_LEADER] = "leader",
1250         [KILL_ALL] = "all"
1251 };
1252
1253 DEFINE_STRING_TABLE_LOOKUP(kill_who, KillWho);