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