src/login/logind-session.c

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