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