src/login/logind-session.c

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