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                 r = sd_event_source_set_priority(s->fifo_event_source, SD_EVENT_PRIORITY_IDLE);
 966                 if (r < 0)
 967                         return r;
 968         }
 969
 970         /* Open writing side */
 971         r = open(s->fifo_path, O_WRONLY|O_CLOEXEC|O_NDELAY);
 972         if (r < 0)
 973                 return -errno;
 974
 975         return r;
 976 }
 977
 978 static void session_remove_fifo(Session *s) {
 979         assert(s);
 980
 981         s->fifo_event_source = sd_event_source_unref(s->fifo_event_source);
 982         s->fifo_fd = safe_close(s->fifo_fd);
 983
 984         if (s->fifo_path) {
 985                 unlink(s->fifo_path);
 986                 s->fifo_path = mfree(s->fifo_path);
 987         }
 988 }
 989
 990 bool session_check_gc(Session *s, bool drop_not_started) {
 991         assert(s);
 992
 993         if (drop_not_started && !s->started)
 994                 return false;
 995
 996         if (!s->user)
 997                 return false;
 998
 999         if (s->fifo_fd >= 0) {
1000                 if (pipe_eof(s->fifo_fd) <= 0)
1001                         return true;
1002         }
1003
1004 #if 0 /// elogind supports neither scopes nor jobs
1005         if (s->scope_job && manager_job_is_active(s->manager, s->scope_job))
1006                 return true;
1007
1008         if (s->scope && manager_unit_is_active(s->manager, s->scope))
1009                 return true;
1010 #endif // 0
1011
1012         if ( s->user->manager
1013           && (cg_is_empty_recursive (SYSTEMD_CGROUP_CONTROLLER, s->user->manager->cgroup_root) > 0) )
1014                 return true;
1015
1016         return false;
1017 }
1018
1019 void session_add_to_gc_queue(Session *s) {
1020         assert(s);
1021
1022         if (s->in_gc_queue)
1023                 return;
1024
1025         LIST_PREPEND(gc_queue, s->manager->session_gc_queue, s);
1026         s->in_gc_queue = true;
1027 }
1028
1029 SessionState session_get_state(Session *s) {
1030         assert(s);
1031
1032         /* always check closing first */
1033         if (s->stopping || s->timer_event_source)
1034                 return SESSION_CLOSING;
1035
1036 #if 0 /// elogind does not support systemd scope_jobs
1037         if (s->scope_job || s->fifo_fd < 0)
1038 #else
1039         if (s->fifo_fd < 0)
1040 #endif // 0
1041                 return SESSION_OPENING;
1042
1043         if (session_is_active(s))
1044                 return SESSION_ACTIVE;
1045
1046         return SESSION_ONLINE;
1047 }
1048
1049 int session_kill(Session *s, KillWho who, int signo) {
1050         assert(s);
1051
1052 #if 0 /// Without direct cgroup support, elogind can not kill sessions
1053         if (!s->scope)
1054                 return -ESRCH;
1055
1056         return manager_kill_unit(s->manager, s->scope, who, signo, NULL);
1057 #else
1058         if (who == KILL_LEADER) {
1059                 if (s->leader <= 0)
1060                         return -ESRCH;
1061
1062                 /* FIXME: verify that leader is in cgroup?  */
1063
1064                 if (kill(s->leader, signo) < 0) {
1065                         return log_error_errno(errno, "Failed to kill process leader %d for session %s: %m", s->leader, s->id);
1066                 }
1067                 return 0;
1068         } else {
1069                 bool sigcont = false;
1070                 bool ignore_self = true;
1071                 bool rem = true;
1072                 return cg_kill_recursive (SYSTEMD_CGROUP_CONTROLLER, s->id, signo,
1073                                           sigcont, ignore_self, rem, NULL);
1074         }
1075 #endif // 0
1076 }
1077
1078 static int session_open_vt(Session *s) {
1079         char path[sizeof("/dev/tty") + DECIMAL_STR_MAX(s->vtnr)];
1080
1081         if (s->vtnr < 1)
1082                 return -ENODEV;
1083
1084         if (s->vtfd >= 0)
1085                 return s->vtfd;
1086
1087         sprintf(path, "/dev/tty%u", s->vtnr);
1088         s->vtfd = open_terminal(path, O_RDWR | O_CLOEXEC | O_NONBLOCK | O_NOCTTY);
1089         if (s->vtfd < 0)
1090                 return log_error_errno(s->vtfd, "cannot open VT %s of session %s: %m", path, s->id);
1091
1092         return s->vtfd;
1093 }
1094
1095 int session_prepare_vt(Session *s) {
1096         int vt, r;
1097         struct vt_mode mode = { 0 };
1098
1099         if (s->vtnr < 1)
1100                 return 0;
1101
1102         vt = session_open_vt(s);
1103         if (vt < 0)
1104                 return vt;
1105
1106         r = fchown(vt, s->user->uid, -1);
1107         if (r < 0) {
1108                 r = log_error_errno(errno,
1109                                     "Cannot change owner of /dev/tty%u: %m",
1110                                     s->vtnr);
1111                 goto error;
1112         }
1113
1114         r = ioctl(vt, KDSKBMODE, K_OFF);
1115         if (r < 0) {
1116                 r = log_error_errno(errno,
1117                                     "Cannot set K_OFF on /dev/tty%u: %m",
1118                                     s->vtnr);
1119                 goto error;
1120         }
1121
1122         r = ioctl(vt, KDSETMODE, KD_GRAPHICS);
1123         if (r < 0) {
1124                 r = log_error_errno(errno,
1125                                     "Cannot set KD_GRAPHICS on /dev/tty%u: %m",
1126                                     s->vtnr);
1127                 goto error;
1128         }
1129
1130         /* Oh, thanks to the VT layer, VT_AUTO does not work with KD_GRAPHICS.
1131          * So we need a dummy handler here which just acknowledges *all* VT
1132          * switch requests. */
1133         mode.mode = VT_PROCESS;
1134         mode.relsig = SIGRTMIN;
1135         mode.acqsig = SIGRTMIN + 1;
1136         r = ioctl(vt, VT_SETMODE, &mode);
1137         if (r < 0) {
1138                 r = log_error_errno(errno,
1139                                     "Cannot set VT_PROCESS on /dev/tty%u: %m",
1140                                     s->vtnr);
1141                 goto error;
1142         }
1143
1144         return 0;
1145
1146 error:
1147         session_restore_vt(s);
1148         return r;
1149 }
1150
1151 void session_restore_vt(Session *s) {
1152
1153         static const struct vt_mode mode = {
1154                 .mode = VT_AUTO,
1155         };
1156
1157         _cleanup_free_ char *utf8 = NULL;
1158         int vt, kb, old_fd;
1159
1160         /* We need to get a fresh handle to the virtual terminal,
1161          * since the old file-descriptor is potentially in a hung-up
1162          * state after the controlling process exited; we do a
1163          * little dance to avoid having the terminal be available
1164          * for reuse before we've cleaned it up.
1165          */
1166         old_fd = s->vtfd;
1167         s->vtfd = -1;
1168
1169         vt = session_open_vt(s);
1170         safe_close(old_fd);
1171
1172         if (vt < 0)
1173                 return;
1174
1175         (void) ioctl(vt, KDSETMODE, KD_TEXT);
1176
1177         if (read_one_line_file("/sys/module/vt/parameters/default_utf8", &utf8) >= 0 && *utf8 == '1')
1178                 kb = K_UNICODE;
1179         else
1180                 kb = K_XLATE;
1181
1182         (void) ioctl(vt, KDSKBMODE, kb);
1183
1184         (void) ioctl(vt, VT_SETMODE, &mode);
1185         (void) fchown(vt, 0, (gid_t) -1);
1186
1187         s->vtfd = safe_close(s->vtfd);
1188 }
1189
1190 void session_leave_vt(Session *s) {
1191         int r;
1192
1193         assert(s);
1194
1195         /* This is called whenever we get a VT-switch signal from the kernel.
1196          * We acknowledge all of them unconditionally. Note that session are
1197          * free to overwrite those handlers and we only register them for
1198          * sessions with controllers. Legacy sessions are not affected.
1199          * However, if we switch from a non-legacy to a legacy session, we must
1200          * make sure to pause all device before acknowledging the switch. We
1201          * process the real switch only after we are notified via sysfs, so the
1202          * legacy session might have already started using the devices. If we
1203          * don't pause the devices before the switch, we might confuse the
1204          * session we switch to. */
1205
1206         if (s->vtfd < 0)
1207                 return;
1208
1209         session_device_pause_all(s);
1210         r = ioctl(s->vtfd, VT_RELDISP, 1);
1211         if (r < 0)
1212                 log_debug_errno(errno, "Cannot release VT of session %s: %m", s->id);
1213 }
1214
1215 bool session_is_controller(Session *s, const char *sender) {
1216         assert(s);
1217
1218         return streq_ptr(s->controller, sender);
1219 }
1220
1221 static void session_release_controller(Session *s, bool notify) {
1222         _cleanup_free_ char *name = NULL;
1223         SessionDevice *sd;
1224
1225         if (!s->controller)
1226                 return;
1227
1228         name = s->controller;
1229
1230         /* By resetting the controller before releasing the devices, we won't
1231          * send notification signals. This avoids sending useless notifications
1232          * if the controller is released on disconnects. */
1233         if (!notify)
1234                 s->controller = NULL;
1235
1236         while ((sd = hashmap_first(s->devices)))
1237                 session_device_free(sd);
1238
1239         s->controller = NULL;
1240         s->track = sd_bus_track_unref(s->track);
1241 }
1242
1243 static int on_bus_track(sd_bus_track *track, void *userdata) {
1244         Session *s = userdata;
1245
1246         assert(track);
1247         assert(s);
1248
1249         session_drop_controller(s);
1250
1251         return 0;
1252 }
1253
1254 int session_set_controller(Session *s, const char *sender, bool force) {
1255         _cleanup_free_ char *name = NULL;
1256         int r;
1257
1258         assert(s);
1259         assert(sender);
1260
1261         if (session_is_controller(s, sender))
1262                 return 0;
1263         if (s->controller && !force)
1264                 return -EBUSY;
1265
1266         name = strdup(sender);
1267         if (!name)
1268                 return -ENOMEM;
1269
1270         s->track = sd_bus_track_unref(s->track);
1271         r = sd_bus_track_new(s->manager->bus, &s->track, on_bus_track, s);
1272         if (r < 0)
1273                 return r;
1274
1275         r = sd_bus_track_add_name(s->track, name);
1276         if (r < 0)
1277                 return r;
1278
1279         /* When setting a session controller, we forcibly mute the VT and set
1280          * it into graphics-mode. Applications can override that by changing
1281          * VT state after calling TakeControl(). However, this serves as a good
1282          * default and well-behaving controllers can now ignore VTs entirely.
1283          * Note that we reset the VT on ReleaseControl() and if the controller
1284          * exits.
1285          * If logind crashes/restarts, we restore the controller during restart
1286          * or reset the VT in case it crashed/exited, too. */
1287         r = session_prepare_vt(s);
1288         if (r < 0) {
1289                 s->track = sd_bus_track_unref(s->track);
1290                 return r;
1291         }
1292
1293         session_release_controller(s, true);
1294         s->controller = name;
1295         name = NULL;
1296         session_save(s);
1297
1298         return 0;
1299 }
1300
1301 void session_drop_controller(Session *s) {
1302         assert(s);
1303
1304         if (!s->controller)
1305                 return;
1306
1307         s->track = sd_bus_track_unref(s->track);
1308         session_release_controller(s, false);
1309         session_save(s);
1310         session_restore_vt(s);
1311 }
1312
1313 static const char* const session_state_table[_SESSION_STATE_MAX] = {
1314         [SESSION_OPENING] = "opening",
1315         [SESSION_ONLINE] = "online",
1316         [SESSION_ACTIVE] = "active",
1317         [SESSION_CLOSING] = "closing"
1318 };
1319
1320 DEFINE_STRING_TABLE_LOOKUP(session_state, SessionState);
1321
1322 static const char* const session_type_table[_SESSION_TYPE_MAX] = {
1323         [SESSION_UNSPECIFIED] = "unspecified",
1324         [SESSION_TTY] = "tty",
1325         [SESSION_X11] = "x11",
1326         [SESSION_WAYLAND] = "wayland",
1327         [SESSION_MIR] = "mir",
1328         [SESSION_WEB] = "web",
1329 };
1330
1331 DEFINE_STRING_TABLE_LOOKUP(session_type, SessionType);
1332
1333 static const char* const session_class_table[_SESSION_CLASS_MAX] = {
1334         [SESSION_USER] = "user",
1335         [SESSION_GREETER] = "greeter",
1336         [SESSION_LOCK_SCREEN] = "lock-screen",
1337         [SESSION_BACKGROUND] = "background"
1338 };
1339
1340 DEFINE_STRING_TABLE_LOOKUP(session_class, SessionClass);
1341
1342 static const char* const kill_who_table[_KILL_WHO_MAX] = {
1343         [KILL_LEADER] = "leader",
1344         [KILL_ALL] = "all"
1345 };
1346
1347 DEFINE_STRING_TABLE_LOOKUP(kill_who, KillWho);