src/login/logind-session.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <errno.h>
   4 #include <fcntl.h>
   5 #include <linux/kd.h>
   6 #include <linux/vt.h>
   7 #include <signal.h>
   8 #include <sys/ioctl.h>
   9 #include <sys/stat.h>
  10 #include <unistd.h>
  11
  12 #include "sd-messages.h"
  13
  14 #include "alloc-util.h"
  15 #include "audit-util.h"
  16 #include "bus-error.h"
  17 #include "bus-util.h"
  18 #include "env-file.h"
  19 #include "escape.h"
  20 #include "fd-util.h"
  21 #include "fileio.h"
  22 #include "format-util.h"
  23 #include "io-util.h"
  24 #include "logind-dbus.h"
  25 #include "logind-seat-dbus.h"
  26 #include "logind-session-dbus.h"
  27 #include "logind-session.h"
  28 #include "logind-user-dbus.h"
  29 #include "mkdir.h"
  30 #include "parse-util.h"
  31 #include "path-util.h"
  32 #include "process-util.h"
  33 #include "serialize.h"
  34 #include "string-table.h"
  35 #include "strv.h"
  36 #include "terminal-util.h"
  37 #include "tmpfile-util.h"
  38 #include "user-util.h"
  39 #include "util.h"
  40
  41 #define RELEASE_USEC (20*USEC_PER_SEC)
  42
  43 static void session_remove_fifo(Session *s);
  44 static void session_restore_vt(Session *s);
  45
  46 int session_new(Session **ret, Manager *m, const char *id) {
  47         _cleanup_(session_freep) Session *s = NULL;
  48         int r;
  49
  50         assert(ret);
  51         assert(m);
  52         assert(id);
  53
  54         if (!session_id_valid(id))
  55                 return -EINVAL;
  56
  57         s = new(Session, 1);
  58         if (!s)
  59                 return -ENOMEM;
  60
  61         *s = (Session) {
  62                 .manager = m,
  63                 .fifo_fd = -1,
  64                 .vtfd = -1,
  65                 .audit_id = AUDIT_SESSION_INVALID,
  66                 .tty_validity = _TTY_VALIDITY_INVALID,
  67         };
  68
  69         s->state_file = path_join("/run/systemd/sessions", id);
  70         if (!s->state_file)
  71                 return -ENOMEM;
  72
  73         s->id = basename(s->state_file);
  74
  75         s->devices = hashmap_new(&devt_hash_ops);
  76         if (!s->devices)
  77                 return -ENOMEM;
  78
  79         r = hashmap_put(m->sessions, s->id, s);
  80         if (r < 0)
  81                 return r;
  82
  83         *ret = TAKE_PTR(s);
  84         return 0;
  85 }
  86
  87 Session* session_free(Session *s) {
  88         SessionDevice *sd;
  89
  90         if (!s)
  91                 return NULL;
  92
  93         if (s->in_gc_queue)
  94                 LIST_REMOVE(gc_queue, s->manager->session_gc_queue, s);
  95
  96         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
  97
  98         session_drop_controller(s);
  99
 100         while ((sd = hashmap_first(s->devices)))
 101                 session_device_free(sd);
 102
 103         hashmap_free(s->devices);
 104
 105         if (s->user) {
 106                 LIST_REMOVE(sessions_by_user, s->user->sessions, s);
 107
 108                 if (s->user->display == s)
 109                         s->user->display = NULL;
 110
 111                 user_update_last_session_timer(s->user);
 112         }
 113
 114         if (s->seat) {
 115                 if (s->seat->active == s)
 116                         s->seat->active = NULL;
 117                 if (s->seat->pending_switch == s)
 118                         s->seat->pending_switch = NULL;
 119
 120                 seat_evict_position(s->seat, s);
 121                 LIST_REMOVE(sessions_by_seat, s->seat->sessions, s);
 122         }
 123
 124         if (s->scope) {
 125                 hashmap_remove(s->manager->session_units, s->scope);
 126                 free(s->scope);
 127         }
 128
 129         if (pid_is_valid(s->leader))
 130                 (void) hashmap_remove_value(s->manager->sessions_by_leader, PID_TO_PTR(s->leader), s);
 131
 132         free(s->scope_job);
 133
 134         sd_bus_message_unref(s->create_message);
 135
 136         free(s->tty);
 137         free(s->display);
 138         free(s->remote_host);
 139         free(s->remote_user);
 140         free(s->service);
 141         free(s->desktop);
 142
 143         hashmap_remove(s->manager->sessions, s->id);
 144
 145         sd_event_source_unref(s->fifo_event_source);
 146         safe_close(s->fifo_fd);
 147
 148         /* Note that we remove neither the state file nor the fifo path here, since we want both to survive
 149          * daemon restarts */
 150         free(s->state_file);
 151         free(s->fifo_path);
 152
 153         return mfree(s);
 154 }
 155
 156 void session_set_user(Session *s, User *u) {
 157         assert(s);
 158         assert(!s->user);
 159
 160         s->user = u;
 161         LIST_PREPEND(sessions_by_user, u->sessions, s);
 162
 163         user_update_last_session_timer(u);
 164 }
 165
 166 int session_set_leader(Session *s, pid_t pid) {
 167         int r;
 168
 169         assert(s);
 170
 171         if (!pid_is_valid(pid))
 172                 return -EINVAL;
 173
 174         if (s->leader == pid)
 175                 return 0;
 176
 177         r = hashmap_put(s->manager->sessions_by_leader, PID_TO_PTR(pid), s);
 178         if (r < 0)
 179                 return r;
 180
 181         if (pid_is_valid(s->leader))
 182                 (void) hashmap_remove_value(s->manager->sessions_by_leader, PID_TO_PTR(s->leader), s);
 183
 184         s->leader = pid;
 185         (void) audit_session_from_pid(pid, &s->audit_id);
 186
 187         return 1;
 188 }
 189
 190 static void session_save_devices(Session *s, FILE *f) {
 191         SessionDevice *sd;
 192         Iterator i;
 193
 194         if (!hashmap_isempty(s->devices)) {
 195                 fprintf(f, "DEVICES=");
 196                 HASHMAP_FOREACH(sd, s->devices, i)
 197                         fprintf(f, "%u:%u ", major(sd->dev), minor(sd->dev));
 198                 fprintf(f, "\n");
 199         }
 200 }
 201
 202 int session_save(Session *s) {
 203         _cleanup_free_ char *temp_path = NULL;
 204         _cleanup_fclose_ FILE *f = NULL;
 205         int r = 0;
 206
 207         assert(s);
 208
 209         if (!s->user)
 210                 return -ESTALE;
 211
 212         if (!s->started)
 213                 return 0;
 214
 215         r = mkdir_safe_label("/run/systemd/sessions", 0755, 0, 0, MKDIR_WARN_MODE);
 216         if (r < 0)
 217                 goto fail;
 218
 219         r = fopen_temporary(s->state_file, &f, &temp_path);
 220         if (r < 0)
 221                 goto fail;
 222
 223         (void) fchmod(fileno(f), 0644);
 224
 225         fprintf(f,
 226                 "# This is private data. Do not parse.\n"
 227                 "UID="UID_FMT"\n"
 228                 "USER=%s\n"
 229                 "ACTIVE=%i\n"
 230                 "IS_DISPLAY=%i\n"
 231                 "STATE=%s\n"
 232                 "REMOTE=%i\n",
 233                 s->user->user_record->uid,
 234                 s->user->user_record->user_name,
 235                 session_is_active(s),
 236                 s->user->display == s,
 237                 session_state_to_string(session_get_state(s)),
 238                 s->remote);
 239
 240         if (s->type >= 0)
 241                 fprintf(f, "TYPE=%s\n", session_type_to_string(s->type));
 242
 243         if (s->original_type >= 0)
 244                 fprintf(f, "ORIGINAL_TYPE=%s\n", session_type_to_string(s->original_type));
 245
 246         if (s->class >= 0)
 247                 fprintf(f, "CLASS=%s\n", session_class_to_string(s->class));
 248
 249         if (s->scope)
 250                 fprintf(f, "SCOPE=%s\n", s->scope);
 251         if (s->scope_job)
 252                 fprintf(f, "SCOPE_JOB=%s\n", s->scope_job);
 253
 254         if (s->fifo_path)
 255                 fprintf(f, "FIFO=%s\n", s->fifo_path);
 256
 257         if (s->seat)
 258                 fprintf(f, "SEAT=%s\n", s->seat->id);
 259
 260         if (s->tty)
 261                 fprintf(f, "TTY=%s\n", s->tty);
 262
 263         if (s->tty_validity >= 0)
 264                 fprintf(f, "TTY_VALIDITY=%s\n", tty_validity_to_string(s->tty_validity));
 265
 266         if (s->display)
 267                 fprintf(f, "DISPLAY=%s\n", s->display);
 268
 269         if (s->remote_host) {
 270                 _cleanup_free_ char *escaped;
 271
 272                 escaped = cescape(s->remote_host);
 273                 if (!escaped) {
 274                         r = -ENOMEM;
 275                         goto fail;
 276                 }
 277
 278                 fprintf(f, "REMOTE_HOST=%s\n", escaped);
 279         }
 280
 281         if (s->remote_user) {
 282                 _cleanup_free_ char *escaped;
 283
 284                 escaped = cescape(s->remote_user);
 285                 if (!escaped) {
 286                         r = -ENOMEM;
 287                         goto fail;
 288                 }
 289
 290                 fprintf(f, "REMOTE_USER=%s\n", escaped);
 291         }
 292
 293         if (s->service) {
 294                 _cleanup_free_ char *escaped;
 295
 296                 escaped = cescape(s->service);
 297                 if (!escaped) {
 298                         r = -ENOMEM;
 299                         goto fail;
 300                 }
 301
 302                 fprintf(f, "SERVICE=%s\n", escaped);
 303         }
 304
 305         if (s->desktop) {
 306                 _cleanup_free_ char *escaped;
 307
 308                 escaped = cescape(s->desktop);
 309                 if (!escaped) {
 310                         r = -ENOMEM;
 311                         goto fail;
 312                 }
 313
 314                 fprintf(f, "DESKTOP=%s\n", escaped);
 315         }
 316
 317         if (s->seat && seat_has_vts(s->seat))
 318                 fprintf(f, "VTNR=%u\n", s->vtnr);
 319
 320         if (!s->vtnr)
 321                 fprintf(f, "POSITION=%u\n", s->position);
 322
 323         if (pid_is_valid(s->leader))
 324                 fprintf(f, "LEADER="PID_FMT"\n", s->leader);
 325
 326         if (audit_session_is_valid(s->audit_id))
 327                 fprintf(f, "AUDIT=%"PRIu32"\n", s->audit_id);
 328
 329         if (dual_timestamp_is_set(&s->timestamp))
 330                 fprintf(f,
 331                         "REALTIME="USEC_FMT"\n"
 332                         "MONOTONIC="USEC_FMT"\n",
 333                         s->timestamp.realtime,
 334                         s->timestamp.monotonic);
 335
 336         if (s->controller) {
 337                 fprintf(f, "CONTROLLER=%s\n", s->controller);
 338                 session_save_devices(s, f);
 339         }
 340
 341         r = fflush_and_check(f);
 342         if (r < 0)
 343                 goto fail;
 344
 345         if (rename(temp_path, s->state_file) < 0) {
 346                 r = -errno;
 347                 goto fail;
 348         }
 349
 350         return 0;
 351
 352 fail:
 353         (void) unlink(s->state_file);
 354
 355         if (temp_path)
 356                 (void) unlink(temp_path);
 357
 358         return log_error_errno(r, "Failed to save session data %s: %m", s->state_file);
 359 }
 360
 361 static int session_load_devices(Session *s, const char *devices) {
 362         const char *p;
 363         int r = 0;
 364
 365         assert(s);
 366
 367         for (p = devices;;) {
 368                 _cleanup_free_ char *word = NULL;
 369                 SessionDevice *sd;
 370                 dev_t dev;
 371                 int k;
 372
 373                 k = extract_first_word(&p, &word, NULL, 0);
 374                 if (k == 0)
 375                         break;
 376                 if (k < 0) {
 377                         r = k;
 378                         break;
 379                 }
 380
 381                 k = parse_dev(word, &dev);
 382                 if (k < 0) {
 383                         r = k;
 384                         continue;
 385                 }
 386
 387                 /* The file descriptors for loaded devices will be reattached later. */
 388                 k = session_device_new(s, dev, false, &sd);
 389                 if (k < 0)
 390                         r = k;
 391         }
 392
 393         if (r < 0)
 394                 log_error_errno(r, "Loading session devices for session %s failed: %m", s->id);
 395
 396         return r;
 397 }
 398
 399 int session_load(Session *s) {
 400         _cleanup_free_ char *remote = NULL,
 401                 *seat = NULL,
 402                 *tty_validity = NULL,
 403                 *vtnr = NULL,
 404                 *state = NULL,
 405                 *position = NULL,
 406                 *leader = NULL,
 407                 *type = NULL,
 408                 *original_type = NULL,
 409                 *class = NULL,
 410                 *uid = NULL,
 411                 *realtime = NULL,
 412                 *monotonic = NULL,
 413                 *controller = NULL,
 414                 *active = NULL,
 415                 *devices = NULL,
 416                 *is_display = NULL;
 417
 418         int k, r;
 419
 420         assert(s);
 421
 422         r = parse_env_file(NULL, s->state_file,
 423                            "REMOTE",         &remote,
 424                            "SCOPE",          &s->scope,
 425                            "SCOPE_JOB",      &s->scope_job,
 426                            "FIFO",           &s->fifo_path,
 427                            "SEAT",           &seat,
 428                            "TTY",            &s->tty,
 429                            "TTY_VALIDITY",   &tty_validity,
 430                            "DISPLAY",        &s->display,
 431                            "REMOTE_HOST",    &s->remote_host,
 432                            "REMOTE_USER",    &s->remote_user,
 433                            "SERVICE",        &s->service,
 434                            "DESKTOP",        &s->desktop,
 435                            "VTNR",           &vtnr,
 436                            "STATE",          &state,
 437                            "POSITION",       &position,
 438                            "LEADER",         &leader,
 439                            "TYPE",           &type,
 440                            "ORIGINAL_TYPE",  &original_type,
 441                            "CLASS",          &class,
 442                            "UID",            &uid,
 443                            "REALTIME",       &realtime,
 444                            "MONOTONIC",      &monotonic,
 445                            "CONTROLLER",     &controller,
 446                            "ACTIVE",         &active,
 447                            "DEVICES",        &devices,
 448                            "IS_DISPLAY",     &is_display);
 449
 450         if (r < 0)
 451                 return log_error_errno(r, "Failed to read %s: %m", s->state_file);
 452
 453         if (!s->user) {
 454                 uid_t u;
 455                 User *user;
 456
 457                 if (!uid)
 458                         return log_error_errno(SYNTHETIC_ERRNO(ENOENT),
 459                                                "UID not specified for session %s",
 460                                                s->id);
 461
 462                 r = parse_uid(uid, &u);
 463                 if (r < 0)  {
 464                         log_error("Failed to parse UID value %s for session %s.", uid, s->id);
 465                         return r;
 466                 }
 467
 468                 user = hashmap_get(s->manager->users, UID_TO_PTR(u));
 469                 if (!user)
 470                         return log_error_errno(SYNTHETIC_ERRNO(ENOENT),
 471                                                "User of session %s not known.",
 472                                                s->id);
 473
 474                 session_set_user(s, user);
 475         }
 476
 477         if (remote) {
 478                 k = parse_boolean(remote);
 479                 if (k >= 0)
 480                         s->remote = k;
 481         }
 482
 483         if (vtnr)
 484                 safe_atou(vtnr, &s->vtnr);
 485
 486         if (seat && !s->seat) {
 487                 Seat *o;
 488
 489                 o = hashmap_get(s->manager->seats, seat);
 490                 if (o)
 491                         r = seat_attach_session(o, s);
 492                 if (!o || r < 0)
 493                         log_error("Cannot attach session %s to seat %s", s->id, seat);
 494         }
 495
 496         if (!s->seat || !seat_has_vts(s->seat))
 497                 s->vtnr = 0;
 498
 499         if (position && s->seat) {
 500                 unsigned npos;
 501
 502                 safe_atou(position, &npos);
 503                 seat_claim_position(s->seat, s, npos);
 504         }
 505
 506         if (tty_validity) {
 507                 TTYValidity v;
 508
 509                 v = tty_validity_from_string(tty_validity);
 510                 if (v < 0)
 511                         log_debug("Failed to parse TTY validity: %s", tty_validity);
 512                 else
 513                         s->tty_validity = v;
 514         }
 515
 516         if (leader) {
 517                 pid_t pid;
 518
 519                 r = parse_pid(leader, &pid);
 520                 if (r < 0)
 521                         log_debug_errno(r, "Failed to parse leader PID of session: %s", leader);
 522                 else {
 523                         r = session_set_leader(s, pid);
 524                         if (r < 0)
 525                                 log_warning_errno(r, "Failed to set session leader PID, ignoring: %m");
 526                 }
 527         }
 528
 529         if (type) {
 530                 SessionType t;
 531
 532                 t = session_type_from_string(type);
 533                 if (t >= 0)
 534                         s->type = t;
 535         }
 536
 537         if (original_type) {
 538                 SessionType ot;
 539
 540                 ot = session_type_from_string(original_type);
 541                 if (ot >= 0)
 542                         s->original_type = ot;
 543         } else
 544                 /* Pre-v246 compat: initialize original_type if not set in the state file */
 545                 s->original_type = s->type;
 546
 547         if (class) {
 548                 SessionClass c;
 549
 550                 c = session_class_from_string(class);
 551                 if (c >= 0)
 552                         s->class = c;
 553         }
 554
 555         if (state && streq(state, "closing"))
 556                 s->stopping = true;
 557
 558         if (s->fifo_path) {
 559                 int fd;
 560
 561                 /* If we open an unopened pipe for reading we will not
 562                    get an EOF. to trigger an EOF we hence open it for
 563                    writing, but close it right away which then will
 564                    trigger the EOF. This will happen immediately if no
 565                    other process has the FIFO open for writing, i. e.
 566                    when the session died before logind (re)started. */
 567
 568                 fd = session_create_fifo(s);
 569                 safe_close(fd);
 570         }
 571
 572         if (realtime)
 573                 (void) deserialize_usec(realtime, &s->timestamp.realtime);
 574         if (monotonic)
 575                 (void) deserialize_usec(monotonic, &s->timestamp.monotonic);
 576
 577         if (active) {
 578                 k = parse_boolean(active);
 579                 if (k >= 0)
 580                         s->was_active = k;
 581         }
 582
 583         if (is_display) {
 584                 /* Note that when enumerating users are loaded before sessions, hence the display session to use is
 585                  * something we have to store along with the session and not the user, as in that case we couldn't
 586                  * apply it at the time we load the user. */
 587
 588                 k = parse_boolean(is_display);
 589                 if (k < 0)
 590                         log_warning_errno(k, "Failed to parse IS_DISPLAY session property: %m");
 591                 else if (k > 0)
 592                         s->user->display = s;
 593         }
 594
 595         if (controller) {
 596                 if (bus_name_has_owner(s->manager->bus, controller, NULL) > 0) {
 597                         session_set_controller(s, controller, false, false);
 598                         session_load_devices(s, devices);
 599                 } else
 600                         session_restore_vt(s);
 601         }
 602
 603         return r;
 604 }
 605
 606 int session_activate(Session *s) {
 607         unsigned num_pending;
 608
 609         assert(s);
 610         assert(s->user);
 611
 612         if (!s->seat)
 613                 return -EOPNOTSUPP;
 614
 615         if (s->seat->active == s)
 616                 return 0;
 617
 618         /* on seats with VTs, we let VTs manage session-switching */
 619         if (seat_has_vts(s->seat)) {
 620                 if (s->vtnr == 0)
 621                         return -EOPNOTSUPP;
 622
 623                 return chvt(s->vtnr);
 624         }
 625
 626         /* On seats without VTs, we implement session-switching in logind. We
 627          * try to pause all session-devices and wait until the session
 628          * controller acknowledged them. Once all devices are asleep, we simply
 629          * switch the active session and be done.
 630          * We save the session we want to switch to in seat->pending_switch and
 631          * seat_complete_switch() will perform the final switch. */
 632
 633         s->seat->pending_switch = s;
 634
 635         /* if no devices are running, immediately perform the session switch */
 636         num_pending = session_device_try_pause_all(s);
 637         if (!num_pending)
 638                 seat_complete_switch(s->seat);
 639
 640         return 0;
 641 }
 642
 643 static int session_start_scope(Session *s, sd_bus_message *properties, sd_bus_error *error) {
 644         int r;
 645
 646         assert(s);
 647         assert(s->user);
 648
 649         if (!s->scope) {
 650                 _cleanup_free_ char *scope = NULL;
 651                 const char *description;
 652
 653                 s->scope_job = mfree(s->scope_job);
 654
 655                 scope = strjoin("session-", s->id, ".scope");
 656                 if (!scope)
 657                         return log_oom();
 658
 659                 description = strjoina("Session ", s->id, " of user ", s->user->user_record->user_name);
 660
 661                 r = manager_start_scope(
 662                                 s->manager,
 663                                 scope,
 664                                 s->leader,
 665                                 s->user->slice,
 666                                 description,
 667                                 /* These two have StopWhenUnneeded= set, hence add a dep towards them */
 668                                 STRV_MAKE(s->user->runtime_dir_service,
 669                                           s->user->service),
 670                                 /* And order us after some more */
 671                                 STRV_MAKE("systemd-logind.service",
 672                                           "systemd-user-sessions.service",
 673                                           s->user->runtime_dir_service,
 674                                           s->user->service),
 675                                 user_record_home_directory(s->user->user_record),
 676                                 properties,
 677                                 error,
 678                                 &s->scope_job);
 679                 if (r < 0)
 680                         return log_error_errno(r, "Failed to start session scope %s: %s",
 681                                                scope, bus_error_message(error, r));
 682
 683                 s->scope = TAKE_PTR(scope);
 684         }
 685
 686         (void) hashmap_put(s->manager->session_units, s->scope, s);
 687
 688         return 0;
 689 }
 690
 691 int session_start(Session *s, sd_bus_message *properties, sd_bus_error *error) {
 692         int r;
 693
 694         assert(s);
 695
 696         if (!s->user)
 697                 return -ESTALE;
 698
 699         if (s->stopping)
 700                 return -EINVAL;
 701
 702         if (s->started)
 703                 return 0;
 704
 705         r = user_start(s->user);
 706         if (r < 0)
 707                 return r;
 708
 709         r = session_start_scope(s, properties, error);
 710         if (r < 0)
 711                 return r;
 712
 713         log_struct(s->class == SESSION_BACKGROUND ? LOG_DEBUG : LOG_INFO,
 714                    "MESSAGE_ID=" SD_MESSAGE_SESSION_START_STR,
 715                    "SESSION_ID=%s", s->id,
 716                    "USER_ID=%s", s->user->user_record->user_name,
 717                    "LEADER="PID_FMT, s->leader,
 718                    LOG_MESSAGE("New session %s of user %s.", s->id, s->user->user_record->user_name));
 719
 720         if (!dual_timestamp_is_set(&s->timestamp))
 721                 dual_timestamp_get(&s->timestamp);
 722
 723         if (s->seat)
 724                 seat_read_active_vt(s->seat);
 725
 726         s->started = true;
 727
 728         user_elect_display(s->user);
 729
 730         /* Save data */
 731         session_save(s);
 732         user_save(s->user);
 733         if (s->seat)
 734                 seat_save(s->seat);
 735
 736         /* Send signals */
 737         session_send_signal(s, true);
 738         user_send_changed(s->user, "Display", NULL);
 739         if (s->seat) {
 740                 if (s->seat->active == s)
 741                         seat_send_changed(s->seat, "ActiveSession", NULL);
 742         }
 743
 744         return 0;
 745 }
 746
 747 static int session_stop_scope(Session *s, bool force) {
 748         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
 749         int r;
 750
 751         assert(s);
 752
 753         if (!s->scope)
 754                 return 0;
 755
 756         /* Let's always abandon the scope first. This tells systemd that we are not interested anymore, and everything
 757          * that is left in the scope is "left-over". Informing systemd about this has the benefit that it will log
 758          * when killing any processes left after this point. */
 759         r = manager_abandon_scope(s->manager, s->scope, &error);
 760         if (r < 0) {
 761                 log_warning_errno(r, "Failed to abandon session scope, ignoring: %s", bus_error_message(&error, r));
 762                 sd_bus_error_free(&error);
 763         }
 764
 765         s->scope_job = mfree(s->scope_job);
 766
 767         /* Optionally, let's kill everything that's left now. */
 768         if (force ||
 769             (s->user->user_record->kill_processes != 0 &&
 770              (s->user->user_record->kill_processes > 0 ||
 771               manager_shall_kill(s->manager, s->user->user_record->user_name)))) {
 772
 773                 r = manager_stop_unit(s->manager, s->scope, &error, &s->scope_job);
 774                 if (r < 0) {
 775                         if (force)
 776                                 return log_error_errno(r, "Failed to stop session scope: %s", bus_error_message(&error, r));
 777
 778                         log_warning_errno(r, "Failed to stop session scope, ignoring: %s", bus_error_message(&error, r));
 779                 }
 780         } else {
 781
 782                 /* With no killing, this session is allowed to persist in "closing" state indefinitely.
 783                  * Therefore session stop and session removal may be two distinct events.
 784                  * Session stop is quite significant on its own, let's log it. */
 785                 log_struct(s->class == SESSION_BACKGROUND ? LOG_DEBUG : LOG_INFO,
 786                            "SESSION_ID=%s", s->id,
 787                            "USER_ID=%s", s->user->user_record->user_name,
 788                            "LEADER="PID_FMT, s->leader,
 789                            LOG_MESSAGE("Session %s logged out. Waiting for processes to exit.", s->id));
 790         }
 791
 792         return 0;
 793 }
 794
 795 int session_stop(Session *s, bool force) {
 796         int r;
 797
 798         assert(s);
 799
 800         /* This is called whenever we begin with tearing down a session record. It's called in four cases: explicit API
 801          * request via the bus (either directly for the session object or for the seat or user object this session
 802          * belongs to; 'force' is true), or due to automatic GC (i.e. scope vanished; 'force' is false), or because the
 803          * session FIFO saw an EOF ('force' is false), or because the release timer hit ('force' is false). */
 804
 805         if (!s->user)
 806                 return -ESTALE;
 807         if (!s->started)
 808                 return 0;
 809         if (s->stopping)
 810                 return 0;
 811
 812         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 813
 814         if (s->seat)
 815                 seat_evict_position(s->seat, s);
 816
 817         /* We are going down, don't care about FIFOs anymore */
 818         session_remove_fifo(s);
 819
 820         /* Kill cgroup */
 821         r = session_stop_scope(s, force);
 822
 823         s->stopping = true;
 824
 825         user_elect_display(s->user);
 826
 827         session_save(s);
 828         user_save(s->user);
 829
 830         return r;
 831 }
 832
 833 int session_finalize(Session *s) {
 834         SessionDevice *sd;
 835
 836         assert(s);
 837
 838         if (!s->user)
 839                 return -ESTALE;
 840
 841         if (s->started)
 842                 log_struct(s->class == SESSION_BACKGROUND ? LOG_DEBUG : LOG_INFO,
 843                            "MESSAGE_ID=" SD_MESSAGE_SESSION_STOP_STR,
 844                            "SESSION_ID=%s", s->id,
 845                            "USER_ID=%s", s->user->user_record->user_name,
 846                            "LEADER="PID_FMT, s->leader,
 847                            LOG_MESSAGE("Removed session %s.", s->id));
 848
 849         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 850
 851         if (s->seat)
 852                 seat_evict_position(s->seat, s);
 853
 854         /* Kill session devices */
 855         while ((sd = hashmap_first(s->devices)))
 856                 session_device_free(sd);
 857
 858         (void) unlink(s->state_file);
 859         session_add_to_gc_queue(s);
 860         user_add_to_gc_queue(s->user);
 861
 862         if (s->started) {
 863                 session_send_signal(s, false);
 864                 s->started = false;
 865         }
 866
 867         if (s->seat) {
 868                 if (s->seat->active == s)
 869                         seat_set_active(s->seat, NULL);
 870
 871                 seat_save(s->seat);
 872         }
 873
 874         user_save(s->user);
 875         user_send_changed(s->user, "Display", NULL);
 876
 877         return 0;
 878 }
 879
 880 static int release_timeout_callback(sd_event_source *es, uint64_t usec, void *userdata) {
 881         Session *s = userdata;
 882
 883         assert(es);
 884         assert(s);
 885
 886         session_stop(s, false);
 887         return 0;
 888 }
 889
 890 int session_release(Session *s) {
 891         assert(s);
 892
 893         if (!s->started || s->stopping)
 894                 return 0;
 895
 896         if (s->timer_event_source)
 897                 return 0;
 898
 899         return sd_event_add_time_relative(
 900                         s->manager->event,
 901                         &s->timer_event_source,
 902                         CLOCK_MONOTONIC,
 903                         RELEASE_USEC, 0,
 904                         release_timeout_callback, s);
 905 }
 906
 907 bool session_is_active(Session *s) {
 908         assert(s);
 909
 910         if (!s->seat)
 911                 return true;
 912
 913         return s->seat->active == s;
 914 }
 915
 916 static int get_tty_atime(const char *tty, usec_t *atime) {
 917         _cleanup_free_ char *p = NULL;
 918         struct stat st;
 919
 920         assert(tty);
 921         assert(atime);
 922
 923         if (!path_is_absolute(tty)) {
 924                 p = path_join("/dev", tty);
 925                 if (!p)
 926                         return -ENOMEM;
 927
 928                 tty = p;
 929         } else if (!path_startswith(tty, "/dev/"))
 930                 return -ENOENT;
 931
 932         if (lstat(tty, &st) < 0)
 933                 return -errno;
 934
 935         *atime = timespec_load(&st.st_atim);
 936         return 0;
 937 }
 938
 939 static int get_process_ctty_atime(pid_t pid, usec_t *atime) {
 940         _cleanup_free_ char *p = NULL;
 941         int r;
 942
 943         assert(pid > 0);
 944         assert(atime);
 945
 946         r = get_ctty(pid, NULL, &p);
 947         if (r < 0)
 948                 return r;
 949
 950         return get_tty_atime(p, atime);
 951 }
 952
 953 int session_get_idle_hint(Session *s, dual_timestamp *t) {
 954         usec_t atime = 0;
 955         int r;
 956
 957         assert(s);
 958
 959         /* Graphical sessions have an explicit idle hint */
 960         if (SESSION_TYPE_IS_GRAPHICAL(s->type)) {
 961                 if (t)
 962                         *t = s->idle_hint_timestamp;
 963
 964                 return s->idle_hint;
 965         }
 966
 967         /* For sessions with an explicitly configured tty, let's check its atime */
 968         if (s->tty) {
 969                 r = get_tty_atime(s->tty, &atime);
 970                 if (r >= 0)
 971                         goto found_atime;
 972         }
 973
 974         /* For sessions with a leader but no explicitly configured tty, let's check the controlling tty of
 975          * the leader */
 976         if (pid_is_valid(s->leader)) {
 977                 r = get_process_ctty_atime(s->leader, &atime);
 978                 if (r >= 0)
 979                         goto found_atime;
 980         }
 981
 982         if (t)
 983                 *t = DUAL_TIMESTAMP_NULL;
 984
 985         return false;
 986
 987 found_atime:
 988         if (t)
 989                 dual_timestamp_from_realtime(t, atime);
 990
 991         if (s->manager->idle_action_usec <= 0)
 992                 return false;
 993
 994         return usec_add(atime, s->manager->idle_action_usec) <= now(CLOCK_REALTIME);
 995 }
 996
 997 int session_set_idle_hint(Session *s, bool b) {
 998         assert(s);
 999
1000         if (!SESSION_TYPE_IS_GRAPHICAL(s->type))
1001                 return -ENOTTY;
1002
1003         if (s->idle_hint == b)
1004                 return 0;
1005
1006         s->idle_hint = b;
1007         dual_timestamp_get(&s->idle_hint_timestamp);
1008
1009         session_send_changed(s, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
1010
1011         if (s->seat)
1012                 seat_send_changed(s->seat, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
1013
1014         user_send_changed(s->user, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
1015         manager_send_changed(s->manager, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
1016
1017         return 1;
1018 }
1019
1020 int session_get_locked_hint(Session *s) {
1021         assert(s);
1022
1023         return s->locked_hint;
1024 }
1025
1026 void session_set_locked_hint(Session *s, bool b) {
1027         assert(s);
1028
1029         if (s->locked_hint == b)
1030                 return;
1031
1032         s->locked_hint = b;
1033
1034         session_send_changed(s, "LockedHint", NULL);
1035 }
1036
1037 void session_set_type(Session *s, SessionType t) {
1038         assert(s);
1039
1040         if (s->type == t)
1041                 return;
1042
1043         s->type = t;
1044         session_save(s);
1045
1046         session_send_changed(s, "Type", NULL);
1047 }
1048
1049 static int session_dispatch_fifo(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
1050         Session *s = userdata;
1051
1052         assert(s);
1053         assert(s->fifo_fd == fd);
1054
1055         /* EOF on the FIFO means the session died abnormally. */
1056
1057         session_remove_fifo(s);
1058         session_stop(s, false);
1059
1060         return 1;
1061 }
1062
1063 int session_create_fifo(Session *s) {
1064         int r;
1065
1066         assert(s);
1067
1068         /* Create FIFO */
1069         if (!s->fifo_path) {
1070                 r = mkdir_safe_label("/run/systemd/sessions", 0755, 0, 0, MKDIR_WARN_MODE);
1071                 if (r < 0)
1072                         return r;
1073
1074                 s->fifo_path = strjoin("/run/systemd/sessions/", s->id, ".ref");
1075                 if (!s->fifo_path)
1076                         return -ENOMEM;
1077
1078                 if (mkfifo(s->fifo_path, 0600) < 0 && errno != EEXIST)
1079                         return -errno;
1080         }
1081
1082         /* Open reading side */
1083         if (s->fifo_fd < 0) {
1084                 s->fifo_fd = open(s->fifo_path, O_RDONLY|O_CLOEXEC|O_NONBLOCK);
1085                 if (s->fifo_fd < 0)
1086                         return -errno;
1087         }
1088
1089         if (!s->fifo_event_source) {
1090                 r = sd_event_add_io(s->manager->event, &s->fifo_event_source, s->fifo_fd, 0, session_dispatch_fifo, s);
1091                 if (r < 0)
1092                         return r;
1093
1094                 /* Let's make sure we noticed dead sessions before we process new bus requests (which might create new
1095                  * sessions). */
1096                 r = sd_event_source_set_priority(s->fifo_event_source, SD_EVENT_PRIORITY_NORMAL-10);
1097                 if (r < 0)
1098                         return r;
1099         }
1100
1101         /* Open writing side */
1102         r = open(s->fifo_path, O_WRONLY|O_CLOEXEC|O_NONBLOCK);
1103         if (r < 0)
1104                 return -errno;
1105
1106         return r;
1107 }
1108
1109 static void session_remove_fifo(Session *s) {
1110         assert(s);
1111
1112         s->fifo_event_source = sd_event_source_unref(s->fifo_event_source);
1113         s->fifo_fd = safe_close(s->fifo_fd);
1114
1115         if (s->fifo_path) {
1116                 (void) unlink(s->fifo_path);
1117                 s->fifo_path = mfree(s->fifo_path);
1118         }
1119 }
1120
1121 bool session_may_gc(Session *s, bool drop_not_started) {
1122         int r;
1123
1124         assert(s);
1125
1126         if (drop_not_started && !s->started)
1127                 return true;
1128
1129         if (!s->user)
1130                 return true;
1131
1132         if (s->fifo_fd >= 0) {
1133                 if (pipe_eof(s->fifo_fd) <= 0)
1134                         return false;
1135         }
1136
1137         if (s->scope_job) {
1138                 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1139
1140                 r = manager_job_is_active(s->manager, s->scope_job, &error);
1141                 if (r < 0)
1142                         log_debug_errno(r, "Failed to determine whether job '%s' is pending, ignoring: %s", s->scope_job, bus_error_message(&error, r));
1143                 if (r != 0)
1144                         return false;
1145         }
1146
1147         if (s->scope) {
1148                 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1149
1150                 r = manager_unit_is_active(s->manager, s->scope, &error);
1151                 if (r < 0)
1152                         log_debug_errno(r, "Failed to determine whether unit '%s' is active, ignoring: %s", s->scope, bus_error_message(&error, r));
1153                 if (r != 0)
1154                         return false;
1155         }
1156
1157         return true;
1158 }
1159
1160 void session_add_to_gc_queue(Session *s) {
1161         assert(s);
1162
1163         if (s->in_gc_queue)
1164                 return;
1165
1166         LIST_PREPEND(gc_queue, s->manager->session_gc_queue, s);
1167         s->in_gc_queue = true;
1168 }
1169
1170 SessionState session_get_state(Session *s) {
1171         assert(s);
1172
1173         /* always check closing first */
1174         if (s->stopping || s->timer_event_source)
1175                 return SESSION_CLOSING;
1176
1177         if (s->scope_job || s->fifo_fd < 0)
1178                 return SESSION_OPENING;
1179
1180         if (session_is_active(s))
1181                 return SESSION_ACTIVE;
1182
1183         return SESSION_ONLINE;
1184 }
1185
1186 int session_kill(Session *s, KillWho who, int signo) {
1187         assert(s);
1188
1189         if (!s->scope)
1190                 return -ESRCH;
1191
1192         return manager_kill_unit(s->manager, s->scope, who, signo, NULL);
1193 }
1194
1195 static int session_open_vt(Session *s) {
1196         char path[sizeof("/dev/tty") + DECIMAL_STR_MAX(s->vtnr)];
1197
1198         if (s->vtnr < 1)
1199                 return -ENODEV;
1200
1201         if (s->vtfd >= 0)
1202                 return s->vtfd;
1203
1204         sprintf(path, "/dev/tty%u", s->vtnr);
1205         s->vtfd = open_terminal(path, O_RDWR | O_CLOEXEC | O_NONBLOCK | O_NOCTTY);
1206         if (s->vtfd < 0)
1207                 return log_error_errno(s->vtfd, "cannot open VT %s of session %s: %m", path, s->id);
1208
1209         return s->vtfd;
1210 }
1211
1212 static int session_prepare_vt(Session *s) {
1213         int vt, r;
1214         struct vt_mode mode = {};
1215
1216         if (s->vtnr < 1)
1217                 return 0;
1218
1219         vt = session_open_vt(s);
1220         if (vt < 0)
1221                 return vt;
1222
1223         r = fchown(vt, s->user->user_record->uid, -1);
1224         if (r < 0) {
1225                 r = log_error_errno(errno,
1226                                     "Cannot change owner of /dev/tty%u: %m",
1227                                     s->vtnr);
1228                 goto error;
1229         }
1230
1231         r = ioctl(vt, KDSKBMODE, K_OFF);
1232         if (r < 0) {
1233                 r = log_error_errno(errno,
1234                                     "Cannot set K_OFF on /dev/tty%u: %m",
1235                                     s->vtnr);
1236                 goto error;
1237         }
1238
1239         r = ioctl(vt, KDSETMODE, KD_GRAPHICS);
1240         if (r < 0) {
1241                 r = log_error_errno(errno,
1242                                     "Cannot set KD_GRAPHICS on /dev/tty%u: %m",
1243                                     s->vtnr);
1244                 goto error;
1245         }
1246
1247         /* Oh, thanks to the VT layer, VT_AUTO does not work with KD_GRAPHICS.
1248          * So we need a dummy handler here which just acknowledges *all* VT
1249          * switch requests. */
1250         mode.mode = VT_PROCESS;
1251         mode.relsig = SIGRTMIN;
1252         mode.acqsig = SIGRTMIN + 1;
1253         r = ioctl(vt, VT_SETMODE, &mode);
1254         if (r < 0) {
1255                 r = log_error_errno(errno,
1256                                     "Cannot set VT_PROCESS on /dev/tty%u: %m",
1257                                     s->vtnr);
1258                 goto error;
1259         }
1260
1261         return 0;
1262
1263 error:
1264         session_restore_vt(s);
1265         return r;
1266 }
1267
1268 static void session_restore_vt(Session *s) {
1269         int r;
1270
1271         r = vt_restore(s->vtfd);
1272         if (r == -EIO) {
1273                 int vt, old_fd;
1274
1275                 /* It might happen if the controlling process exited before or while we were
1276                  * restoring the VT as it would leave the old file-descriptor in a hung-up
1277                  * state. In this case let's retry with a fresh handle to the virtual terminal. */
1278
1279                 /* We do a little dance to avoid having the terminal be available
1280                  * for reuse before we've cleaned it up. */
1281                 old_fd = TAKE_FD(s->vtfd);
1282
1283                 vt = session_open_vt(s);
1284                 safe_close(old_fd);
1285
1286                 if (vt >= 0)
1287                         r = vt_restore(vt);
1288         }
1289
1290         if (r < 0)
1291                 log_warning_errno(r, "Failed to restore VT, ignoring: %m");
1292
1293         s->vtfd = safe_close(s->vtfd);
1294 }
1295
1296 void session_leave_vt(Session *s) {
1297         int r;
1298
1299         assert(s);
1300
1301         /* This is called whenever we get a VT-switch signal from the kernel.
1302          * We acknowledge all of them unconditionally. Note that session are
1303          * free to overwrite those handlers and we only register them for
1304          * sessions with controllers. Legacy sessions are not affected.
1305          * However, if we switch from a non-legacy to a legacy session, we must
1306          * make sure to pause all device before acknowledging the switch. We
1307          * process the real switch only after we are notified via sysfs, so the
1308          * legacy session might have already started using the devices. If we
1309          * don't pause the devices before the switch, we might confuse the
1310          * session we switch to. */
1311
1312         if (s->vtfd < 0)
1313                 return;
1314
1315         session_device_pause_all(s);
1316         r = vt_release(s->vtfd, false);
1317         if (r < 0)
1318                 log_debug_errno(r, "Cannot release VT of session %s: %m", s->id);
1319 }
1320
1321 bool session_is_controller(Session *s, const char *sender) {
1322         assert(s);
1323
1324         return streq_ptr(s->controller, sender);
1325 }
1326
1327 static void session_release_controller(Session *s, bool notify) {
1328         _cleanup_free_ char *name = NULL;
1329         SessionDevice *sd;
1330
1331         if (!s->controller)
1332                 return;
1333
1334         name = s->controller;
1335
1336         /* By resetting the controller before releasing the devices, we won't
1337          * send notification signals. This avoids sending useless notifications
1338          * if the controller is released on disconnects. */
1339         if (!notify)
1340                 s->controller = NULL;
1341
1342         while ((sd = hashmap_first(s->devices)))
1343                 session_device_free(sd);
1344
1345         s->controller = NULL;
1346         s->track = sd_bus_track_unref(s->track);
1347 }
1348
1349 static int on_bus_track(sd_bus_track *track, void *userdata) {
1350         Session *s = userdata;
1351
1352         assert(track);
1353         assert(s);
1354
1355         session_drop_controller(s);
1356
1357         return 0;
1358 }
1359
1360 int session_set_controller(Session *s, const char *sender, bool force, bool prepare) {
1361         _cleanup_free_ char *name = NULL;
1362         int r;
1363
1364         assert(s);
1365         assert(sender);
1366
1367         if (session_is_controller(s, sender))
1368                 return 0;
1369         if (s->controller && !force)
1370                 return -EBUSY;
1371
1372         name = strdup(sender);
1373         if (!name)
1374                 return -ENOMEM;
1375
1376         s->track = sd_bus_track_unref(s->track);
1377         r = sd_bus_track_new(s->manager->bus, &s->track, on_bus_track, s);
1378         if (r < 0)
1379                 return r;
1380
1381         r = sd_bus_track_add_name(s->track, name);
1382         if (r < 0)
1383                 return r;
1384
1385         /* When setting a session controller, we forcibly mute the VT and set
1386          * it into graphics-mode. Applications can override that by changing
1387          * VT state after calling TakeControl(). However, this serves as a good
1388          * default and well-behaving controllers can now ignore VTs entirely.
1389          * Note that we reset the VT on ReleaseControl() and if the controller
1390          * exits.
1391          * If logind crashes/restarts, we restore the controller during restart
1392          * (without preparing the VT since the controller has probably overridden
1393          * VT state by now) or reset the VT in case it crashed/exited, too. */
1394         if (prepare) {
1395                 r = session_prepare_vt(s);
1396                 if (r < 0) {
1397                         s->track = sd_bus_track_unref(s->track);
1398                         return r;
1399                 }
1400         }
1401
1402         session_release_controller(s, true);
1403         s->controller = TAKE_PTR(name);
1404         session_save(s);
1405
1406         return 0;
1407 }
1408
1409 void session_drop_controller(Session *s) {
1410         assert(s);
1411
1412         if (!s->controller)
1413                 return;
1414
1415         s->track = sd_bus_track_unref(s->track);
1416         session_set_type(s, s->original_type);
1417         session_release_controller(s, false);
1418         session_save(s);
1419         session_restore_vt(s);
1420 }
1421
1422 static const char* const session_state_table[_SESSION_STATE_MAX] = {
1423         [SESSION_OPENING] = "opening",
1424         [SESSION_ONLINE] = "online",
1425         [SESSION_ACTIVE] = "active",
1426         [SESSION_CLOSING] = "closing"
1427 };
1428
1429 DEFINE_STRING_TABLE_LOOKUP(session_state, SessionState);
1430
1431 static const char* const session_type_table[_SESSION_TYPE_MAX] = {
1432         [SESSION_UNSPECIFIED] = "unspecified",
1433         [SESSION_TTY] = "tty",
1434         [SESSION_X11] = "x11",
1435         [SESSION_WAYLAND] = "wayland",
1436         [SESSION_MIR] = "mir",
1437         [SESSION_WEB] = "web",
1438 };
1439
1440 DEFINE_STRING_TABLE_LOOKUP(session_type, SessionType);
1441
1442 static const char* const session_class_table[_SESSION_CLASS_MAX] = {
1443         [SESSION_USER] = "user",
1444         [SESSION_GREETER] = "greeter",
1445         [SESSION_LOCK_SCREEN] = "lock-screen",
1446         [SESSION_BACKGROUND] = "background"
1447 };
1448
1449 DEFINE_STRING_TABLE_LOOKUP(session_class, SessionClass);
1450
1451 static const char* const kill_who_table[_KILL_WHO_MAX] = {
1452         [KILL_LEADER] = "leader",
1453         [KILL_ALL] = "all"
1454 };
1455
1456 DEFINE_STRING_TABLE_LOOKUP(kill_who, KillWho);
1457
1458 static const char* const tty_validity_table[_TTY_VALIDITY_MAX] = {
1459         [TTY_FROM_PAM] = "from-pam",
1460         [TTY_FROM_UTMP] = "from-utmp",
1461         [TTY_UTMP_INCONSISTENT] = "utmp-inconsistent",
1462 };
1463
1464 DEFINE_STRING_TABLE_LOOKUP(tty_validity, TTYValidity);