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