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(s->manager->event,
 900                                  &s->timer_event_source,
 901                                  CLOCK_MONOTONIC,
 902                                  usec_add(now(CLOCK_MONOTONIC), RELEASE_USEC), 0,
 903                                  release_timeout_callback, s);
 904 }
 905
 906 bool session_is_active(Session *s) {
 907         assert(s);
 908
 909         if (!s->seat)
 910                 return true;
 911
 912         return s->seat->active == s;
 913 }
 914
 915 static int get_tty_atime(const char *tty, usec_t *atime) {
 916         _cleanup_free_ char *p = NULL;
 917         struct stat st;
 918
 919         assert(tty);
 920         assert(atime);
 921
 922         if (!path_is_absolute(tty)) {
 923                 p = path_join("/dev", tty);
 924                 if (!p)
 925                         return -ENOMEM;
 926
 927                 tty = p;
 928         } else if (!path_startswith(tty, "/dev/"))
 929                 return -ENOENT;
 930
 931         if (lstat(tty, &st) < 0)
 932                 return -errno;
 933
 934         *atime = timespec_load(&st.st_atim);
 935         return 0;
 936 }
 937
 938 static int get_process_ctty_atime(pid_t pid, usec_t *atime) {
 939         _cleanup_free_ char *p = NULL;
 940         int r;
 941
 942         assert(pid > 0);
 943         assert(atime);
 944
 945         r = get_ctty(pid, NULL, &p);
 946         if (r < 0)
 947                 return r;
 948
 949         return get_tty_atime(p, atime);
 950 }
 951
 952 int session_get_idle_hint(Session *s, dual_timestamp *t) {
 953         usec_t atime = 0;
 954         int r;
 955
 956         assert(s);
 957
 958         /* Graphical sessions have an explicit idle hint */
 959         if (SESSION_TYPE_IS_GRAPHICAL(s->type)) {
 960                 if (t)
 961                         *t = s->idle_hint_timestamp;
 962
 963                 return s->idle_hint;
 964         }
 965
 966         /* For sessions with an explicitly configured tty, let's check its atime */
 967         if (s->tty) {
 968                 r = get_tty_atime(s->tty, &atime);
 969                 if (r >= 0)
 970                         goto found_atime;
 971         }
 972
 973         /* For sessions with a leader but no explicitly configured tty, let's check the controlling tty of
 974          * the leader */
 975         if (pid_is_valid(s->leader)) {
 976                 r = get_process_ctty_atime(s->leader, &atime);
 977                 if (r >= 0)
 978                         goto found_atime;
 979         }
 980
 981         if (t)
 982                 *t = DUAL_TIMESTAMP_NULL;
 983
 984         return false;
 985
 986 found_atime:
 987         if (t)
 988                 dual_timestamp_from_realtime(t, atime);
 989
 990         if (s->manager->idle_action_usec <= 0)
 991                 return false;
 992
 993         return usec_add(atime, s->manager->idle_action_usec) <= now(CLOCK_REALTIME);
 994 }
 995
 996 int session_set_idle_hint(Session *s, bool b) {
 997         assert(s);
 998
 999         if (!SESSION_TYPE_IS_GRAPHICAL(s->type))
1000                 return -ENOTTY;
1001
1002         if (s->idle_hint == b)
1003                 return 0;
1004
1005         s->idle_hint = b;
1006         dual_timestamp_get(&s->idle_hint_timestamp);
1007
1008         session_send_changed(s, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
1009
1010         if (s->seat)
1011                 seat_send_changed(s->seat, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
1012
1013         user_send_changed(s->user, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
1014         manager_send_changed(s->manager, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
1015
1016         return 1;
1017 }
1018
1019 int session_get_locked_hint(Session *s) {
1020         assert(s);
1021
1022         return s->locked_hint;
1023 }
1024
1025 void session_set_locked_hint(Session *s, bool b) {
1026         assert(s);
1027
1028         if (s->locked_hint == b)
1029                 return;
1030
1031         s->locked_hint = b;
1032
1033         session_send_changed(s, "LockedHint", NULL);
1034 }
1035
1036 void session_set_type(Session *s, SessionType t) {
1037         assert(s);
1038
1039         if (s->type == t)
1040                 return;
1041
1042         s->type = t;
1043         session_save(s);
1044
1045         session_send_changed(s, "Type", NULL);
1046 }
1047
1048 static int session_dispatch_fifo(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
1049         Session *s = userdata;
1050
1051         assert(s);
1052         assert(s->fifo_fd == fd);
1053
1054         /* EOF on the FIFO means the session died abnormally. */
1055
1056         session_remove_fifo(s);
1057         session_stop(s, false);
1058
1059         return 1;
1060 }
1061
1062 int session_create_fifo(Session *s) {
1063         int r;
1064
1065         assert(s);
1066
1067         /* Create FIFO */
1068         if (!s->fifo_path) {
1069                 r = mkdir_safe_label("/run/systemd/sessions", 0755, 0, 0, MKDIR_WARN_MODE);
1070                 if (r < 0)
1071                         return r;
1072
1073                 s->fifo_path = strjoin("/run/systemd/sessions/", s->id, ".ref");
1074                 if (!s->fifo_path)
1075                         return -ENOMEM;
1076
1077                 if (mkfifo(s->fifo_path, 0600) < 0 && errno != EEXIST)
1078                         return -errno;
1079         }
1080
1081         /* Open reading side */
1082         if (s->fifo_fd < 0) {
1083                 s->fifo_fd = open(s->fifo_path, O_RDONLY|O_CLOEXEC|O_NONBLOCK);
1084                 if (s->fifo_fd < 0)
1085                         return -errno;
1086         }
1087
1088         if (!s->fifo_event_source) {
1089                 r = sd_event_add_io(s->manager->event, &s->fifo_event_source, s->fifo_fd, 0, session_dispatch_fifo, s);
1090                 if (r < 0)
1091                         return r;
1092
1093                 /* Let's make sure we noticed dead sessions before we process new bus requests (which might create new
1094                  * sessions). */
1095                 r = sd_event_source_set_priority(s->fifo_event_source, SD_EVENT_PRIORITY_NORMAL-10);
1096                 if (r < 0)
1097                         return r;
1098         }
1099
1100         /* Open writing side */
1101         r = open(s->fifo_path, O_WRONLY|O_CLOEXEC|O_NONBLOCK);
1102         if (r < 0)
1103                 return -errno;
1104
1105         return r;
1106 }
1107
1108 static void session_remove_fifo(Session *s) {
1109         assert(s);
1110
1111         s->fifo_event_source = sd_event_source_unref(s->fifo_event_source);
1112         s->fifo_fd = safe_close(s->fifo_fd);
1113
1114         if (s->fifo_path) {
1115                 (void) unlink(s->fifo_path);
1116                 s->fifo_path = mfree(s->fifo_path);
1117         }
1118 }
1119
1120 bool session_may_gc(Session *s, bool drop_not_started) {
1121         int r;
1122
1123         assert(s);
1124
1125         if (drop_not_started && !s->started)
1126                 return true;
1127
1128         if (!s->user)
1129                 return true;
1130
1131         if (s->fifo_fd >= 0) {
1132                 if (pipe_eof(s->fifo_fd) <= 0)
1133                         return false;
1134         }
1135
1136         if (s->scope_job) {
1137                 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1138
1139                 r = manager_job_is_active(s->manager, s->scope_job, &error);
1140                 if (r < 0)
1141                         log_debug_errno(r, "Failed to determine whether job '%s' is pending, ignoring: %s", s->scope_job, bus_error_message(&error, r));
1142                 if (r != 0)
1143                         return false;
1144         }
1145
1146         if (s->scope) {
1147                 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1148
1149                 r = manager_unit_is_active(s->manager, s->scope, &error);
1150                 if (r < 0)
1151                         log_debug_errno(r, "Failed to determine whether unit '%s' is active, ignoring: %s", s->scope, bus_error_message(&error, r));
1152                 if (r != 0)
1153                         return false;
1154         }
1155
1156         return true;
1157 }
1158
1159 void session_add_to_gc_queue(Session *s) {
1160         assert(s);
1161
1162         if (s->in_gc_queue)
1163                 return;
1164
1165         LIST_PREPEND(gc_queue, s->manager->session_gc_queue, s);
1166         s->in_gc_queue = true;
1167 }
1168
1169 SessionState session_get_state(Session *s) {
1170         assert(s);
1171
1172         /* always check closing first */
1173         if (s->stopping || s->timer_event_source)
1174                 return SESSION_CLOSING;
1175
1176         if (s->scope_job || s->fifo_fd < 0)
1177                 return SESSION_OPENING;
1178
1179         if (session_is_active(s))
1180                 return SESSION_ACTIVE;
1181
1182         return SESSION_ONLINE;
1183 }
1184
1185 int session_kill(Session *s, KillWho who, int signo) {
1186         assert(s);
1187
1188         if (!s->scope)
1189                 return -ESRCH;
1190
1191         return manager_kill_unit(s->manager, s->scope, who, signo, NULL);
1192 }
1193
1194 static int session_open_vt(Session *s) {
1195         char path[sizeof("/dev/tty") + DECIMAL_STR_MAX(s->vtnr)];
1196
1197         if (s->vtnr < 1)
1198                 return -ENODEV;
1199
1200         if (s->vtfd >= 0)
1201                 return s->vtfd;
1202
1203         sprintf(path, "/dev/tty%u", s->vtnr);
1204         s->vtfd = open_terminal(path, O_RDWR | O_CLOEXEC | O_NONBLOCK | O_NOCTTY);
1205         if (s->vtfd < 0)
1206                 return log_error_errno(s->vtfd, "cannot open VT %s of session %s: %m", path, s->id);
1207
1208         return s->vtfd;
1209 }
1210
1211 static int session_prepare_vt(Session *s) {
1212         int vt, r;
1213         struct vt_mode mode = {};
1214
1215         if (s->vtnr < 1)
1216                 return 0;
1217
1218         vt = session_open_vt(s);
1219         if (vt < 0)
1220                 return vt;
1221
1222         r = fchown(vt, s->user->user_record->uid, -1);
1223         if (r < 0) {
1224                 r = log_error_errno(errno,
1225                                     "Cannot change owner of /dev/tty%u: %m",
1226                                     s->vtnr);
1227                 goto error;
1228         }
1229
1230         r = ioctl(vt, KDSKBMODE, K_OFF);
1231         if (r < 0) {
1232                 r = log_error_errno(errno,
1233                                     "Cannot set K_OFF on /dev/tty%u: %m",
1234                                     s->vtnr);
1235                 goto error;
1236         }
1237
1238         r = ioctl(vt, KDSETMODE, KD_GRAPHICS);
1239         if (r < 0) {
1240                 r = log_error_errno(errno,
1241                                     "Cannot set KD_GRAPHICS on /dev/tty%u: %m",
1242                                     s->vtnr);
1243                 goto error;
1244         }
1245
1246         /* Oh, thanks to the VT layer, VT_AUTO does not work with KD_GRAPHICS.
1247          * So we need a dummy handler here which just acknowledges *all* VT
1248          * switch requests. */
1249         mode.mode = VT_PROCESS;
1250         mode.relsig = SIGRTMIN;
1251         mode.acqsig = SIGRTMIN + 1;
1252         r = ioctl(vt, VT_SETMODE, &mode);
1253         if (r < 0) {
1254                 r = log_error_errno(errno,
1255                                     "Cannot set VT_PROCESS on /dev/tty%u: %m",
1256                                     s->vtnr);
1257                 goto error;
1258         }
1259
1260         return 0;
1261
1262 error:
1263         session_restore_vt(s);
1264         return r;
1265 }
1266
1267 static void session_restore_vt(Session *s) {
1268         int r;
1269
1270         r = vt_restore(s->vtfd);
1271         if (r == -EIO) {
1272                 int vt, old_fd;
1273
1274                 /* It might happen if the controlling process exited before or while we were
1275                  * restoring the VT as it would leave the old file-descriptor in a hung-up
1276                  * state. In this case let's retry with a fresh handle to the virtual terminal. */
1277
1278                 /* We do a little dance to avoid having the terminal be available
1279                  * for reuse before we've cleaned it up. */
1280                 old_fd = TAKE_FD(s->vtfd);
1281
1282                 vt = session_open_vt(s);
1283                 safe_close(old_fd);
1284
1285                 if (vt >= 0)
1286                         r = vt_restore(vt);
1287         }
1288
1289         if (r < 0)
1290                 log_warning_errno(r, "Failed to restore VT, ignoring: %m");
1291
1292         s->vtfd = safe_close(s->vtfd);
1293 }
1294
1295 void session_leave_vt(Session *s) {
1296         int r;
1297
1298         assert(s);
1299
1300         /* This is called whenever we get a VT-switch signal from the kernel.
1301          * We acknowledge all of them unconditionally. Note that session are
1302          * free to overwrite those handlers and we only register them for
1303          * sessions with controllers. Legacy sessions are not affected.
1304          * However, if we switch from a non-legacy to a legacy session, we must
1305          * make sure to pause all device before acknowledging the switch. We
1306          * process the real switch only after we are notified via sysfs, so the
1307          * legacy session might have already started using the devices. If we
1308          * don't pause the devices before the switch, we might confuse the
1309          * session we switch to. */
1310
1311         if (s->vtfd < 0)
1312                 return;
1313
1314         session_device_pause_all(s);
1315         r = vt_release(s->vtfd, false);
1316         if (r < 0)
1317                 log_debug_errno(r, "Cannot release VT of session %s: %m", s->id);
1318 }
1319
1320 bool session_is_controller(Session *s, const char *sender) {
1321         assert(s);
1322
1323         return streq_ptr(s->controller, sender);
1324 }
1325
1326 static void session_release_controller(Session *s, bool notify) {
1327         _cleanup_free_ char *name = NULL;
1328         SessionDevice *sd;
1329
1330         if (!s->controller)
1331                 return;
1332
1333         name = s->controller;
1334
1335         /* By resetting the controller before releasing the devices, we won't
1336          * send notification signals. This avoids sending useless notifications
1337          * if the controller is released on disconnects. */
1338         if (!notify)
1339                 s->controller = NULL;
1340
1341         while ((sd = hashmap_first(s->devices)))
1342                 session_device_free(sd);
1343
1344         s->controller = NULL;
1345         s->track = sd_bus_track_unref(s->track);
1346 }
1347
1348 static int on_bus_track(sd_bus_track *track, void *userdata) {
1349         Session *s = userdata;
1350
1351         assert(track);
1352         assert(s);
1353
1354         session_drop_controller(s);
1355
1356         return 0;
1357 }
1358
1359 int session_set_controller(Session *s, const char *sender, bool force, bool prepare) {
1360         _cleanup_free_ char *name = NULL;
1361         int r;
1362
1363         assert(s);
1364         assert(sender);
1365
1366         if (session_is_controller(s, sender))
1367                 return 0;
1368         if (s->controller && !force)
1369                 return -EBUSY;
1370
1371         name = strdup(sender);
1372         if (!name)
1373                 return -ENOMEM;
1374
1375         s->track = sd_bus_track_unref(s->track);
1376         r = sd_bus_track_new(s->manager->bus, &s->track, on_bus_track, s);
1377         if (r < 0)
1378                 return r;
1379
1380         r = sd_bus_track_add_name(s->track, name);
1381         if (r < 0)
1382                 return r;
1383
1384         /* When setting a session controller, we forcibly mute the VT and set
1385          * it into graphics-mode. Applications can override that by changing
1386          * VT state after calling TakeControl(). However, this serves as a good
1387          * default and well-behaving controllers can now ignore VTs entirely.
1388          * Note that we reset the VT on ReleaseControl() and if the controller
1389          * exits.
1390          * If logind crashes/restarts, we restore the controller during restart
1391          * (without preparing the VT since the controller has probably overridden
1392          * VT state by now) or reset the VT in case it crashed/exited, too. */
1393         if (prepare) {
1394                 r = session_prepare_vt(s);
1395                 if (r < 0) {
1396                         s->track = sd_bus_track_unref(s->track);
1397                         return r;
1398                 }
1399         }
1400
1401         session_release_controller(s, true);
1402         s->controller = TAKE_PTR(name);
1403         session_save(s);
1404
1405         return 0;
1406 }
1407
1408 void session_drop_controller(Session *s) {
1409         assert(s);
1410
1411         if (!s->controller)
1412                 return;
1413
1414         s->track = sd_bus_track_unref(s->track);
1415         session_set_type(s, s->original_type);
1416         session_release_controller(s, false);
1417         session_save(s);
1418         session_restore_vt(s);
1419 }
1420
1421 static const char* const session_state_table[_SESSION_STATE_MAX] = {
1422         [SESSION_OPENING] = "opening",
1423         [SESSION_ONLINE] = "online",
1424         [SESSION_ACTIVE] = "active",
1425         [SESSION_CLOSING] = "closing"
1426 };
1427
1428 DEFINE_STRING_TABLE_LOOKUP(session_state, SessionState);
1429
1430 static const char* const session_type_table[_SESSION_TYPE_MAX] = {
1431         [SESSION_UNSPECIFIED] = "unspecified",
1432         [SESSION_TTY] = "tty",
1433         [SESSION_X11] = "x11",
1434         [SESSION_WAYLAND] = "wayland",
1435         [SESSION_MIR] = "mir",
1436         [SESSION_WEB] = "web",
1437 };
1438
1439 DEFINE_STRING_TABLE_LOOKUP(session_type, SessionType);
1440
1441 static const char* const session_class_table[_SESSION_CLASS_MAX] = {
1442         [SESSION_USER] = "user",
1443         [SESSION_GREETER] = "greeter",
1444         [SESSION_LOCK_SCREEN] = "lock-screen",
1445         [SESSION_BACKGROUND] = "background"
1446 };
1447
1448 DEFINE_STRING_TABLE_LOOKUP(session_class, SessionClass);
1449
1450 static const char* const kill_who_table[_KILL_WHO_MAX] = {
1451         [KILL_LEADER] = "leader",
1452         [KILL_ALL] = "all"
1453 };
1454
1455 DEFINE_STRING_TABLE_LOOKUP(kill_who, KillWho);
1456
1457 static const char* const tty_validity_table[_TTY_VALIDITY_MAX] = {
1458         [TTY_FROM_PAM] = "from-pam",
1459         [TTY_FROM_UTMP] = "from-utmp",
1460         [TTY_UTMP_INCONSISTENT] = "utmp-inconsistent",
1461 };
1462
1463 DEFINE_STRING_TABLE_LOOKUP(tty_validity, TTYValidity);