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                 timestamp_deserialize(realtime, &s->timestamp.realtime);
 451         if (monotonic)
 452                 timestamp_deserialize(monotonic, &s->timestamp.monotonic);
 453
 454         if (controller) {
 455                 if (bus_name_has_owner(s->manager->bus, controller, NULL) > 0)
 456                         session_set_controller(s, controller, false);
 457                 else
 458                         session_restore_vt(s);
 459         }
 460
 461         return r;
 462 }
 463
 464 int session_activate(Session *s) {
 465         unsigned int num_pending;
 466
 467         assert(s);
 468         assert(s->user);
 469
 470         if (!s->seat)
 471                 return -EOPNOTSUPP;
 472
 473         if (s->seat->active == s)
 474                 return 0;
 475
 476         /* on seats with VTs, we let VTs manage session-switching */
 477         if (seat_has_vts(s->seat)) {
 478                 if (!s->vtnr)
 479                         return -EOPNOTSUPP;
 480
 481                 return chvt(s->vtnr);
 482         }
 483
 484         /* On seats without VTs, we implement session-switching in logind. We
 485          * try to pause all session-devices and wait until the session
 486          * controller acknowledged them. Once all devices are asleep, we simply
 487          * switch the active session and be done.
 488          * We save the session we want to switch to in seat->pending_switch and
 489          * seat_complete_switch() will perform the final switch. */
 490
 491         s->seat->pending_switch = s;
 492
 493         /* if no devices are running, immediately perform the session switch */
 494         num_pending = session_device_try_pause_all(s);
 495         if (!num_pending)
 496                 seat_complete_switch(s->seat);
 497
 498         return 0;
 499 }
 500
 501 static int session_start_scope(Session *s) {
 502         int r;
 503
 504         assert(s);
 505         assert(s->user);
 506
 507         if (!s->scope) {
 508                 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
 509                 char *scope, *job = NULL;
 510                 const char *description;
 511
 512                 scope = strjoin("session-", s->id, ".scope", NULL);
 513                 if (!scope)
 514                         return log_oom();
 515
 516                 description = strjoina("Session ", s->id, " of user ", s->user->name);
 517
 518                 r = manager_start_scope(
 519                                 s->manager,
 520                                 scope,
 521                                 s->leader,
 522                                 s->user->slice,
 523                                 description,
 524                                 "systemd-logind.service",
 525                                 "systemd-user-sessions.service",
 526                                 (uint64_t) -1, /* disable TasksMax= for the scope, rely on the slice setting for it */
 527                                 &error,
 528                                 &job);
 529                 if (r < 0) {
 530                         log_error_errno(r, "Failed to start session scope %s: %s", scope, bus_error_message(&error, r));
 531                         free(scope);
 532                         return r;
 533                 } else {
 534                         s->scope = scope;
 535
 536                         free(s->scope_job);
 537                         s->scope_job = job;
 538                 }
 539         }
 540
 541         if (s->scope)
 542                 (void) hashmap_put(s->manager->session_units, s->scope, s);
 543
 544         return 0;
 545 }
 546
 547 int session_start(Session *s) {
 548         int r;
 549
 550         assert(s);
 551
 552         if (!s->user)
 553                 return -ESTALE;
 554
 555         if (s->started)
 556                 return 0;
 557
 558         r = user_start(s->user);
 559         if (r < 0)
 560                 return r;
 561
 562         /* Create cgroup */
 563         r = session_start_scope(s);
 564         if (r < 0)
 565                 return r;
 566
 567         log_struct(s->class == SESSION_BACKGROUND ? LOG_DEBUG : LOG_INFO,
 568                    LOG_MESSAGE_ID(SD_MESSAGE_SESSION_START),
 569                    "SESSION_ID=%s", s->id,
 570                    "USER_ID=%s", s->user->name,
 571                    "LEADER="PID_FMT, s->leader,
 572                    LOG_MESSAGE("New session %s of user %s.", s->id, s->user->name),
 573                    NULL);
 574
 575         if (!dual_timestamp_is_set(&s->timestamp))
 576                 dual_timestamp_get(&s->timestamp);
 577
 578         if (s->seat)
 579                 seat_read_active_vt(s->seat);
 580
 581         s->started = true;
 582
 583         user_elect_display(s->user);
 584
 585         /* Save data */
 586         session_save(s);
 587         user_save(s->user);
 588         if (s->seat)
 589                 seat_save(s->seat);
 590
 591         /* Send signals */
 592         session_send_signal(s, true);
 593         user_send_changed(s->user, "Sessions", "Display", NULL);
 594         if (s->seat) {
 595                 if (s->seat->active == s)
 596                         seat_send_changed(s->seat, "Sessions", "ActiveSession", NULL);
 597                 else
 598                         seat_send_changed(s->seat, "Sessions", NULL);
 599         }
 600
 601         return 0;
 602 }
 603
 604 static int session_stop_scope(Session *s, bool force) {
 605         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
 606         int r;
 607
 608         assert(s);
 609
 610         if (!s->scope)
 611                 return 0;
 612
 613         /* Let's always abandon the scope first. This tells systemd that we are not interested anymore, and everything
 614          * that is left in the scope is "left-over". Informing systemd about this has the benefit that it will log
 615          * when killing any processes left after this point. */
 616         r = manager_abandon_scope(s->manager, s->scope, &error);
 617         if (r < 0)
 618                 log_warning_errno(r, "Failed to abandon session scope, ignoring: %s", bus_error_message(&error, r));
 619
 620         /* Optionally, let's kill everything that's left now. */
 621         if (force || manager_shall_kill(s->manager, s->user->name)) {
 622                 char *job = NULL;
 623
 624                 r = manager_stop_unit(s->manager, s->scope, &error, &job);
 625                 if (r < 0)
 626                         return log_error_errno(r, "Failed to stop session scope: %s", bus_error_message(&error, r));
 627
 628                 free(s->scope_job);
 629                 s->scope_job = job;
 630         } else
 631                 s->scope_job = mfree(s->scope_job);
 632
 633         return 0;
 634 }
 635
 636 int session_stop(Session *s, bool force) {
 637         int r;
 638
 639         assert(s);
 640
 641         if (!s->user)
 642                 return -ESTALE;
 643
 644         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 645
 646         if (s->seat)
 647                 seat_evict_position(s->seat, s);
 648
 649         /* We are going down, don't care about FIFOs anymore */
 650         session_remove_fifo(s);
 651
 652         /* Kill cgroup */
 653         r = session_stop_scope(s, force);
 654
 655         s->stopping = true;
 656
 657         user_elect_display(s->user);
 658
 659         session_save(s);
 660         user_save(s->user);
 661
 662         return r;
 663 }
 664
 665 int session_finalize(Session *s) {
 666         SessionDevice *sd;
 667
 668         assert(s);
 669
 670         if (!s->user)
 671                 return -ESTALE;
 672
 673         if (s->started)
 674                 log_struct(s->class == SESSION_BACKGROUND ? LOG_DEBUG : LOG_INFO,
 675                            LOG_MESSAGE_ID(SD_MESSAGE_SESSION_STOP),
 676                            "SESSION_ID=%s", s->id,
 677                            "USER_ID=%s", s->user->name,
 678                            "LEADER="PID_FMT, s->leader,
 679                            LOG_MESSAGE("Removed session %s.", s->id),
 680                            NULL);
 681
 682         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 683
 684         if (s->seat)
 685                 seat_evict_position(s->seat, s);
 686
 687         /* Kill session devices */
 688         while ((sd = hashmap_first(s->devices)))
 689                 session_device_free(sd);
 690
 691         (void) unlink(s->state_file);
 692         session_add_to_gc_queue(s);
 693         user_add_to_gc_queue(s->user);
 694
 695         if (s->started) {
 696                 session_send_signal(s, false);
 697                 s->started = false;
 698         }
 699
 700         if (s->seat) {
 701                 if (s->seat->active == s)
 702                         seat_set_active(s->seat, NULL);
 703
 704                 seat_save(s->seat);
 705                 seat_send_changed(s->seat, "Sessions", NULL);
 706         }
 707
 708         user_save(s->user);
 709         user_send_changed(s->user, "Sessions", "Display", NULL);
 710
 711         return 0;
 712 }
 713
 714 static int release_timeout_callback(sd_event_source *es, uint64_t usec, void *userdata) {
 715         Session *s = userdata;
 716
 717         assert(es);
 718         assert(s);
 719
 720         session_stop(s, false);
 721         return 0;
 722 }
 723
 724 int session_release(Session *s) {
 725         assert(s);
 726
 727         if (!s->started || s->stopping)
 728                 return 0;
 729
 730         if (s->timer_event_source)
 731                 return 0;
 732
 733         return sd_event_add_time(s->manager->event,
 734                                  &s->timer_event_source,
 735                                  CLOCK_MONOTONIC,
 736                                  now(CLOCK_MONOTONIC) + RELEASE_USEC, 0,
 737                                  release_timeout_callback, s);
 738 }
 739
 740 bool session_is_active(Session *s) {
 741         assert(s);
 742
 743         if (!s->seat)
 744                 return true;
 745
 746         return s->seat->active == s;
 747 }
 748
 749 static int get_tty_atime(const char *tty, usec_t *atime) {
 750         _cleanup_free_ char *p = NULL;
 751         struct stat st;
 752
 753         assert(tty);
 754         assert(atime);
 755
 756         if (!path_is_absolute(tty)) {
 757                 p = strappend("/dev/", tty);
 758                 if (!p)
 759                         return -ENOMEM;
 760
 761                 tty = p;
 762         } else if (!path_startswith(tty, "/dev/"))
 763                 return -ENOENT;
 764
 765         if (lstat(tty, &st) < 0)
 766                 return -errno;
 767
 768         *atime = timespec_load(&st.st_atim);
 769         return 0;
 770 }
 771
 772 static int get_process_ctty_atime(pid_t pid, usec_t *atime) {
 773         _cleanup_free_ char *p = NULL;
 774         int r;
 775
 776         assert(pid > 0);
 777         assert(atime);
 778
 779         r = get_ctty(pid, NULL, &p);
 780         if (r < 0)
 781                 return r;
 782
 783         return get_tty_atime(p, atime);
 784 }
 785
 786 int session_get_idle_hint(Session *s, dual_timestamp *t) {
 787         usec_t atime = 0, n;
 788         int r;
 789
 790         assert(s);
 791
 792         /* Explicit idle hint is set */
 793         if (s->idle_hint) {
 794                 if (t)
 795                         *t = s->idle_hint_timestamp;
 796
 797                 return s->idle_hint;
 798         }
 799
 800         /* Graphical sessions should really implement a real
 801          * idle hint logic */
 802         if (SESSION_TYPE_IS_GRAPHICAL(s->type))
 803                 goto dont_know;
 804
 805         /* For sessions with an explicitly configured tty, let's check
 806          * its atime */
 807         if (s->tty) {
 808                 r = get_tty_atime(s->tty, &atime);
 809                 if (r >= 0)
 810                         goto found_atime;
 811         }
 812
 813         /* For sessions with a leader but no explicitly configured
 814          * tty, let's check the controlling tty of the leader */
 815         if (s->leader > 0) {
 816                 r = get_process_ctty_atime(s->leader, &atime);
 817                 if (r >= 0)
 818                         goto found_atime;
 819         }
 820
 821 dont_know:
 822         if (t)
 823                 *t = s->idle_hint_timestamp;
 824
 825         return 0;
 826
 827 found_atime:
 828         if (t)
 829                 dual_timestamp_from_realtime(t, atime);
 830
 831         n = now(CLOCK_REALTIME);
 832
 833         if (s->manager->idle_action_usec <= 0)
 834                 return 0;
 835
 836         return atime + s->manager->idle_action_usec <= n;
 837 }
 838
 839 void session_set_idle_hint(Session *s, bool b) {
 840         assert(s);
 841
 842         if (s->idle_hint == b)
 843                 return;
 844
 845         s->idle_hint = b;
 846         dual_timestamp_get(&s->idle_hint_timestamp);
 847
 848         session_send_changed(s, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
 849
 850         if (s->seat)
 851                 seat_send_changed(s->seat, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
 852
 853         user_send_changed(s->user, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
 854         manager_send_changed(s->manager, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
 855 }
 856
 857 int session_get_locked_hint(Session *s) {
 858         assert(s);
 859
 860         return s->locked_hint;
 861 }
 862
 863 void session_set_locked_hint(Session *s, bool b) {
 864         assert(s);
 865
 866         if (s->locked_hint == b)
 867                 return;
 868
 869         s->locked_hint = b;
 870
 871         session_send_changed(s, "LockedHint", NULL);
 872 }
 873
 874 static int session_dispatch_fifo(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
 875         Session *s = userdata;
 876
 877         assert(s);
 878         assert(s->fifo_fd == fd);
 879
 880         /* EOF on the FIFO means the session died abnormally. */
 881
 882         session_remove_fifo(s);
 883         session_stop(s, false);
 884
 885         return 1;
 886 }
 887
 888 int session_create_fifo(Session *s) {
 889         int r;
 890
 891         assert(s);
 892
 893         /* Create FIFO */
 894         if (!s->fifo_path) {
 895                 r = mkdir_safe_label("/run/systemd/sessions", 0755, 0, 0);
 896                 if (r < 0)
 897                         return r;
 898
 899                 if (asprintf(&s->fifo_path, "/run/systemd/sessions/%s.ref", s->id) < 0)
 900                         return -ENOMEM;
 901
 902                 if (mkfifo(s->fifo_path, 0600) < 0 && errno != EEXIST)
 903                         return -errno;
 904         }
 905
 906         /* Open reading side */
 907         if (s->fifo_fd < 0) {
 908                 s->fifo_fd = open(s->fifo_path, O_RDONLY|O_CLOEXEC|O_NDELAY);
 909                 if (s->fifo_fd < 0)
 910                         return -errno;
 911
 912         }
 913
 914         if (!s->fifo_event_source) {
 915                 r = sd_event_add_io(s->manager->event, &s->fifo_event_source, s->fifo_fd, 0, session_dispatch_fifo, s);
 916                 if (r < 0)
 917                         return r;
 918
 919                 /* Let's make sure we noticed dead sessions before we process new bus requests (which might create new
 920                  * sessions). */
 921                 r = sd_event_source_set_priority(s->fifo_event_source, SD_EVENT_PRIORITY_NORMAL-10);
 922                 if (r < 0)
 923                         return r;
 924         }
 925
 926         /* Open writing side */
 927         r = open(s->fifo_path, O_WRONLY|O_CLOEXEC|O_NDELAY);
 928         if (r < 0)
 929                 return -errno;
 930
 931         return r;
 932 }
 933
 934 static void session_remove_fifo(Session *s) {
 935         assert(s);
 936
 937         s->fifo_event_source = sd_event_source_unref(s->fifo_event_source);
 938         s->fifo_fd = safe_close(s->fifo_fd);
 939
 940         if (s->fifo_path) {
 941                 unlink(s->fifo_path);
 942                 s->fifo_path = mfree(s->fifo_path);
 943         }
 944 }
 945
 946 bool session_check_gc(Session *s, bool drop_not_started) {
 947         assert(s);
 948
 949         if (drop_not_started && !s->started)
 950                 return false;
 951
 952         if (!s->user)
 953                 return false;
 954
 955         if (s->fifo_fd >= 0) {
 956                 if (pipe_eof(s->fifo_fd) <= 0)
 957                         return true;
 958         }
 959
 960         if (s->scope_job && manager_job_is_active(s->manager, s->scope_job))
 961                 return true;
 962
 963         if (s->scope && manager_unit_is_active(s->manager, s->scope))
 964                 return true;
 965
 966         return false;
 967 }
 968
 969 void session_add_to_gc_queue(Session *s) {
 970         assert(s);
 971
 972         if (s->in_gc_queue)
 973                 return;
 974
 975         LIST_PREPEND(gc_queue, s->manager->session_gc_queue, s);
 976         s->in_gc_queue = true;
 977 }
 978
 979 SessionState session_get_state(Session *s) {
 980         assert(s);
 981
 982         /* always check closing first */
 983         if (s->stopping || s->timer_event_source)
 984                 return SESSION_CLOSING;
 985
 986         if (s->scope_job || s->fifo_fd < 0)
 987                 return SESSION_OPENING;
 988
 989         if (session_is_active(s))
 990                 return SESSION_ACTIVE;
 991
 992         return SESSION_ONLINE;
 993 }
 994
 995 int session_kill(Session *s, KillWho who, int signo) {
 996         assert(s);
 997
 998         if (!s->scope)
 999                 return -ESRCH;
1000
1001         return manager_kill_unit(s->manager, s->scope, who, signo, NULL);
1002 }
1003
1004 static int session_open_vt(Session *s) {
1005         char path[sizeof("/dev/tty") + DECIMAL_STR_MAX(s->vtnr)];
1006
1007         if (s->vtnr < 1)
1008                 return -ENODEV;
1009
1010         if (s->vtfd >= 0)
1011                 return s->vtfd;
1012
1013         sprintf(path, "/dev/tty%u", s->vtnr);
1014         s->vtfd = open_terminal(path, O_RDWR | O_CLOEXEC | O_NONBLOCK | O_NOCTTY);
1015         if (s->vtfd < 0)
1016                 return log_error_errno(s->vtfd, "cannot open VT %s of session %s: %m", path, s->id);
1017
1018         return s->vtfd;
1019 }
1020
1021 int session_prepare_vt(Session *s) {
1022         int vt, r;
1023         struct vt_mode mode = { 0 };
1024
1025         if (s->vtnr < 1)
1026                 return 0;
1027
1028         vt = session_open_vt(s);
1029         if (vt < 0)
1030                 return vt;
1031
1032         r = fchown(vt, s->user->uid, -1);
1033         if (r < 0) {
1034                 r = log_error_errno(errno,
1035                                     "Cannot change owner of /dev/tty%u: %m",
1036                                     s->vtnr);
1037                 goto error;
1038         }
1039
1040         r = ioctl(vt, KDSKBMODE, K_OFF);
1041         if (r < 0) {
1042                 r = log_error_errno(errno,
1043                                     "Cannot set K_OFF on /dev/tty%u: %m",
1044                                     s->vtnr);
1045                 goto error;
1046         }
1047
1048         r = ioctl(vt, KDSETMODE, KD_GRAPHICS);
1049         if (r < 0) {
1050                 r = log_error_errno(errno,
1051                                     "Cannot set KD_GRAPHICS on /dev/tty%u: %m",
1052                                     s->vtnr);
1053                 goto error;
1054         }
1055
1056         /* Oh, thanks to the VT layer, VT_AUTO does not work with KD_GRAPHICS.
1057          * So we need a dummy handler here which just acknowledges *all* VT
1058          * switch requests. */
1059         mode.mode = VT_PROCESS;
1060         mode.relsig = SIGRTMIN;
1061         mode.acqsig = SIGRTMIN + 1;
1062         r = ioctl(vt, VT_SETMODE, &mode);
1063         if (r < 0) {
1064                 r = log_error_errno(errno,
1065                                     "Cannot set VT_PROCESS on /dev/tty%u: %m",
1066                                     s->vtnr);
1067                 goto error;
1068         }
1069
1070         return 0;
1071
1072 error:
1073         session_restore_vt(s);
1074         return r;
1075 }
1076
1077 void session_restore_vt(Session *s) {
1078
1079         static const struct vt_mode mode = {
1080                 .mode = VT_AUTO,
1081         };
1082
1083         _cleanup_free_ char *utf8 = NULL;
1084         int vt, kb, old_fd;
1085
1086         /* We need to get a fresh handle to the virtual terminal,
1087          * since the old file-descriptor is potentially in a hung-up
1088          * state after the controlling process exited; we do a
1089          * little dance to avoid having the terminal be available
1090          * for reuse before we've cleaned it up.
1091          */
1092         old_fd = s->vtfd;
1093         s->vtfd = -1;
1094
1095         vt = session_open_vt(s);
1096         safe_close(old_fd);
1097
1098         if (vt < 0)
1099                 return;
1100
1101         (void) ioctl(vt, KDSETMODE, KD_TEXT);
1102
1103         if (read_one_line_file("/sys/module/vt/parameters/default_utf8", &utf8) >= 0 && *utf8 == '1')
1104                 kb = K_UNICODE;
1105         else
1106                 kb = K_XLATE;
1107
1108         (void) ioctl(vt, KDSKBMODE, kb);
1109
1110         (void) ioctl(vt, VT_SETMODE, &mode);
1111         (void) fchown(vt, 0, (gid_t) -1);
1112
1113         s->vtfd = safe_close(s->vtfd);
1114 }
1115
1116 void session_leave_vt(Session *s) {
1117         int r;
1118
1119         assert(s);
1120
1121         /* This is called whenever we get a VT-switch signal from the kernel.
1122          * We acknowledge all of them unconditionally. Note that session are
1123          * free to overwrite those handlers and we only register them for
1124          * sessions with controllers. Legacy sessions are not affected.
1125          * However, if we switch from a non-legacy to a legacy session, we must
1126          * make sure to pause all device before acknowledging the switch. We
1127          * process the real switch only after we are notified via sysfs, so the
1128          * legacy session might have already started using the devices. If we
1129          * don't pause the devices before the switch, we might confuse the
1130          * session we switch to. */
1131
1132         if (s->vtfd < 0)
1133                 return;
1134
1135         session_device_pause_all(s);
1136         r = ioctl(s->vtfd, VT_RELDISP, 1);
1137         if (r < 0)
1138                 log_debug_errno(errno, "Cannot release VT of session %s: %m", s->id);
1139 }
1140
1141 bool session_is_controller(Session *s, const char *sender) {
1142         assert(s);
1143
1144         return streq_ptr(s->controller, sender);
1145 }
1146
1147 static void session_release_controller(Session *s, bool notify) {
1148         _cleanup_free_ char *name = NULL;
1149         SessionDevice *sd;
1150
1151         if (!s->controller)
1152                 return;
1153
1154         name = s->controller;
1155
1156         /* By resetting the controller before releasing the devices, we won't
1157          * send notification signals. This avoids sending useless notifications
1158          * if the controller is released on disconnects. */
1159         if (!notify)
1160                 s->controller = NULL;
1161
1162         while ((sd = hashmap_first(s->devices)))
1163                 session_device_free(sd);
1164
1165         s->controller = NULL;
1166         s->track = sd_bus_track_unref(s->track);
1167 }
1168
1169 static int on_bus_track(sd_bus_track *track, void *userdata) {
1170         Session *s = userdata;
1171
1172         assert(track);
1173         assert(s);
1174
1175         session_drop_controller(s);
1176
1177         return 0;
1178 }
1179
1180 int session_set_controller(Session *s, const char *sender, bool force) {
1181         _cleanup_free_ char *name = NULL;
1182         int r;
1183
1184         assert(s);
1185         assert(sender);
1186
1187         if (session_is_controller(s, sender))
1188                 return 0;
1189         if (s->controller && !force)
1190                 return -EBUSY;
1191
1192         name = strdup(sender);
1193         if (!name)
1194                 return -ENOMEM;
1195
1196         s->track = sd_bus_track_unref(s->track);
1197         r = sd_bus_track_new(s->manager->bus, &s->track, on_bus_track, s);
1198         if (r < 0)
1199                 return r;
1200
1201         r = sd_bus_track_add_name(s->track, name);
1202         if (r < 0)
1203                 return r;
1204
1205         /* When setting a session controller, we forcibly mute the VT and set
1206          * it into graphics-mode. Applications can override that by changing
1207          * VT state after calling TakeControl(). However, this serves as a good
1208          * default and well-behaving controllers can now ignore VTs entirely.
1209          * Note that we reset the VT on ReleaseControl() and if the controller
1210          * exits.
1211          * If logind crashes/restarts, we restore the controller during restart
1212          * or reset the VT in case it crashed/exited, too. */
1213         r = session_prepare_vt(s);
1214         if (r < 0) {
1215                 s->track = sd_bus_track_unref(s->track);
1216                 return r;
1217         }
1218
1219         session_release_controller(s, true);
1220         s->controller = name;
1221         name = NULL;
1222         session_save(s);
1223
1224         return 0;
1225 }
1226
1227 void session_drop_controller(Session *s) {
1228         assert(s);
1229
1230         if (!s->controller)
1231                 return;
1232
1233         s->track = sd_bus_track_unref(s->track);
1234         session_release_controller(s, false);
1235         session_save(s);
1236         session_restore_vt(s);
1237 }
1238
1239 static const char* const session_state_table[_SESSION_STATE_MAX] = {
1240         [SESSION_OPENING] = "opening",
1241         [SESSION_ONLINE] = "online",
1242         [SESSION_ACTIVE] = "active",
1243         [SESSION_CLOSING] = "closing"
1244 };
1245
1246 DEFINE_STRING_TABLE_LOOKUP(session_state, SessionState);
1247
1248 static const char* const session_type_table[_SESSION_TYPE_MAX] = {
1249         [SESSION_UNSPECIFIED] = "unspecified",
1250         [SESSION_TTY] = "tty",
1251         [SESSION_X11] = "x11",
1252         [SESSION_WAYLAND] = "wayland",
1253         [SESSION_MIR] = "mir",
1254         [SESSION_WEB] = "web",
1255 };
1256
1257 DEFINE_STRING_TABLE_LOOKUP(session_type, SessionType);
1258
1259 static const char* const session_class_table[_SESSION_CLASS_MAX] = {
1260         [SESSION_USER] = "user",
1261         [SESSION_GREETER] = "greeter",
1262         [SESSION_LOCK_SCREEN] = "lock-screen",
1263         [SESSION_BACKGROUND] = "background"
1264 };
1265
1266 DEFINE_STRING_TABLE_LOOKUP(session_class, SessionClass);
1267
1268 static const char* const kill_who_table[_KILL_WHO_MAX] = {
1269         [KILL_LEADER] = "leader",
1270         [KILL_ALL] = "all"
1271 };
1272
1273 DEFINE_STRING_TABLE_LOOKUP(kill_who, KillWho);