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