src/login/logind-session.c

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