src/login/logind-session.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2011 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <errno.h>
  23 #include <fcntl.h>
  24 #include <linux/vt.h>
  25 #include <linux/kd.h>
  26 #include <signal.h>
  27 #include <string.h>
  28 #include <sys/ioctl.h>
  29 #include <unistd.h>
  30
  31 #include "sd-messages.h"
  32 #include "util.h"
  33 #include "mkdir.h"
  34 #include "path-util.h"
  35 #include "fileio.h"
  36 #include "audit.h"
  37 #include "bus-util.h"
  38 #include "bus-error.h"
  39 #include "logind-session.h"
  40 #include "formats-util.h"
  41 #include "terminal-util.h"
  42
  43 // #define RELEASE_USEC (20*USEC_PER_SEC)
  44
  45 static void session_remove_fifo(Session *s);
  46
  47 Session* session_new(Manager *m, const char *id) {
  48         Session *s;
  49
  50         assert(m);
  51         assert(id);
  52         assert(session_id_valid(id));
  53
  54         s = new0(Session, 1);
  55         if (!s)
  56                 return NULL;
  57
  58         s->state_file = strappend("/run/systemd/sessions/", id);
  59         if (!s->state_file) {
  60                 free(s);
  61                 return NULL;
  62         }
  63
  64         s->devices = hashmap_new(&devt_hash_ops);
  65         if (!s->devices) {
  66                 free(s->state_file);
  67                 free(s);
  68                 return NULL;
  69         }
  70
  71         s->id = basename(s->state_file);
  72
  73         if (hashmap_put(m->sessions, s->id, s) < 0) {
  74                 hashmap_free(s->devices);
  75                 free(s->state_file);
  76                 free(s);
  77                 return NULL;
  78         }
  79
  80         s->manager = m;
  81         s->fifo_fd = -1;
  82         s->vtfd = -1;
  83
  84         return s;
  85 }
  86
  87 void session_free(Session *s) {
  88         SessionDevice *sd;
  89
  90         assert(s);
  91
  92         if (s->in_gc_queue)
  93                 LIST_REMOVE(gc_queue, s->manager->session_gc_queue, s);
  94
  95         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
  96
  97         session_remove_fifo(s);
  98
  99         session_drop_controller(s);
 100
 101         while ((sd = hashmap_first(s->devices)))
 102                 session_device_free(sd);
 103
 104         hashmap_free(s->devices);
 105
 106         if (s->user) {
 107                 LIST_REMOVE(sessions_by_user, s->user->sessions, s);
 108
 109                 if (s->user->display == s)
 110                         s->user->display = NULL;
 111         }
 112
 113         if (s->seat) {
 114                 if (s->seat->active == s)
 115                         s->seat->active = NULL;
 116                 if (s->seat->pending_switch == s)
 117                         s->seat->pending_switch = NULL;
 118
 119                 seat_evict_position(s->seat, s);
 120                 LIST_REMOVE(sessions_by_seat, s->seat->sessions, s);
 121         }
 122
 123         if (s->scope) {
 124                 hashmap_remove(s->manager->session_units, s->scope);
 125                 free(s->scope);
 126         }
 127
 128 /// elogind does not support systemd scope_jobs
 129 #if 0
 130         free(s->scope_job);
 131 #endif // 0
 132
 133         sd_bus_message_unref(s->create_message);
 134
 135         free(s->tty);
 136         free(s->display);
 137         free(s->remote_host);
 138         free(s->remote_user);
 139         free(s->service);
 140         free(s->desktop);
 141
 142         hashmap_remove(s->manager->sessions, s->id);
 143
 144         free(s->state_file);
 145         free(s);
 146 }
 147
 148 void session_set_user(Session *s, User *u) {
 149         assert(s);
 150         assert(!s->user);
 151
 152         s->user = u;
 153         LIST_PREPEND(sessions_by_user, u->sessions, s);
 154 }
 155
 156 int session_save(Session *s) {
 157         _cleanup_free_ char *temp_path = NULL;
 158         _cleanup_fclose_ FILE *f = NULL;
 159         int r = 0;
 160
 161         assert(s);
 162
 163         if (!s->user)
 164                 return -ESTALE;
 165
 166         if (!s->started)
 167                 return 0;
 168
 169         r = mkdir_safe_label("/run/systemd/sessions", 0755, 0, 0);
 170         if (r < 0)
 171                 goto fail;
 172
 173         r = fopen_temporary(s->state_file, &f, &temp_path);
 174         if (r < 0)
 175                 goto fail;
 176
 177         assert(s->user);
 178
 179         fchmod(fileno(f), 0644);
 180
 181         fprintf(f,
 182                 "# This is private data. Do not parse.\n"
 183                 "UID="UID_FMT"\n"
 184                 "USER=%s\n"
 185                 "ACTIVE=%i\n"
 186                 "STATE=%s\n"
 187                 "REMOTE=%i\n",
 188                 s->user->uid,
 189                 s->user->name,
 190                 session_is_active(s),
 191                 session_state_to_string(session_get_state(s)),
 192                 s->remote);
 193
 194         if (s->type >= 0)
 195                 fprintf(f, "TYPE=%s\n", session_type_to_string(s->type));
 196
 197         if (s->class >= 0)
 198                 fprintf(f, "CLASS=%s\n", session_class_to_string(s->class));
 199
 200         if (s->scope)
 201                 fprintf(f, "SCOPE=%s\n", s->scope);
 202 /// elogind does not support systemd scope_jobs
 203 #if 0
 204         if (s->scope_job)
 205                 fprintf(f, "SCOPE_JOB=%s\n", s->scope_job);
 206 #endif // 0
 207
 208         if (s->fifo_path)
 209                 fprintf(f, "FIFO=%s\n", s->fifo_path);
 210
 211         if (s->seat)
 212                 fprintf(f, "SEAT=%s\n", s->seat->id);
 213
 214         if (s->tty)
 215                 fprintf(f, "TTY=%s\n", s->tty);
 216
 217         if (s->display)
 218                 fprintf(f, "DISPLAY=%s\n", s->display);
 219
 220         if (s->remote_host) {
 221                 _cleanup_free_ char *escaped;
 222
 223                 escaped = cescape(s->remote_host);
 224                 if (!escaped) {
 225                         r = -ENOMEM;
 226                         goto fail;
 227                 }
 228
 229                 fprintf(f, "REMOTE_HOST=%s\n", escaped);
 230         }
 231
 232         if (s->remote_user) {
 233                 _cleanup_free_ char *escaped;
 234
 235                 escaped = cescape(s->remote_user);
 236                 if (!escaped) {
 237                         r = -ENOMEM;
 238                         goto fail;
 239                 }
 240
 241                 fprintf(f, "REMOTE_USER=%s\n", escaped);
 242         }
 243
 244         if (s->service) {
 245                 _cleanup_free_ char *escaped;
 246
 247                 escaped = cescape(s->service);
 248                 if (!escaped) {
 249                         r = -ENOMEM;
 250                         goto fail;
 251                 }
 252
 253                 fprintf(f, "SERVICE=%s\n", escaped);
 254         }
 255
 256         if (s->desktop) {
 257                 _cleanup_free_ char *escaped;
 258
 259
 260                 escaped = cescape(s->desktop);
 261                 if (!escaped) {
 262                         r = -ENOMEM;
 263                         goto fail;
 264                 }
 265
 266                 fprintf(f, "DESKTOP=%s\n", escaped);
 267         }
 268
 269         if (s->seat && seat_has_vts(s->seat))
 270                 fprintf(f, "VTNR=%u\n", s->vtnr);
 271
 272         if (!s->vtnr)
 273                 fprintf(f, "POSITION=%u\n", s->position);
 274
 275         if (s->leader > 0)
 276                 fprintf(f, "LEADER="PID_FMT"\n", s->leader);
 277
 278         if (s->audit_id > 0)
 279                 fprintf(f, "AUDIT=%"PRIu32"\n", s->audit_id);
 280
 281         if (dual_timestamp_is_set(&s->timestamp))
 282                 fprintf(f,
 283                         "REALTIME="USEC_FMT"\n"
 284                         "MONOTONIC="USEC_FMT"\n",
 285                         s->timestamp.realtime,
 286                         s->timestamp.monotonic);
 287
 288         if (s->controller)
 289                 fprintf(f, "CONTROLLER=%s\n", s->controller);
 290
 291         r = fflush_and_check(f);
 292         if (r < 0)
 293                 goto fail;
 294
 295         if (rename(temp_path, s->state_file) < 0) {
 296                 r = -errno;
 297                 goto fail;
 298         }
 299
 300         return 0;
 301
 302 fail:
 303         (void) unlink(s->state_file);
 304
 305         if (temp_path)
 306                 (void) unlink(temp_path);
 307
 308         return log_error_errno(r, "Failed to save session data %s: %m", s->state_file);
 309 }
 310
 311
 312 int session_load(Session *s) {
 313         _cleanup_free_ char *remote = NULL,
 314                 *seat = NULL,
 315                 *vtnr = NULL,
 316                 *state = NULL,
 317                 *position = NULL,
 318                 *leader = NULL,
 319                 *type = NULL,
 320                 *class = NULL,
 321                 *uid = NULL,
 322                 *realtime = NULL,
 323                 *monotonic = NULL,
 324                 *controller = NULL;
 325
 326         int k, r;
 327
 328         assert(s);
 329
 330         r = parse_env_file(s->state_file, NEWLINE,
 331                            "REMOTE",         &remote,
 332                            "SCOPE",          &s->scope,
 333 /// elogind does not support systemd scope_jobs
 334 #if 0
 335                            "SCOPE_JOB",      &s->scope_job,
 336 #endif // 0
 337                            "FIFO",           &s->fifo_path,
 338                            "SEAT",           &seat,
 339                            "TTY",            &s->tty,
 340                            "DISPLAY",        &s->display,
 341                            "REMOTE_HOST",    &s->remote_host,
 342                            "REMOTE_USER",    &s->remote_user,
 343                            "SERVICE",        &s->service,
 344                            "DESKTOP",        &s->desktop,
 345                            "VTNR",           &vtnr,
 346                            "STATE",          &state,
 347                            "POSITION",       &position,
 348                            "LEADER",         &leader,
 349                            "TYPE",           &type,
 350                            "CLASS",          &class,
 351                            "UID",            &uid,
 352                            "REALTIME",       &realtime,
 353                            "MONOTONIC",      &monotonic,
 354                            "CONTROLLER",     &controller,
 355                            NULL);
 356
 357         if (r < 0)
 358                 return log_error_errno(r, "Failed to read %s: %m", s->state_file);
 359
 360         if (!s->user) {
 361                 uid_t u;
 362                 User *user;
 363
 364                 if (!uid) {
 365                         log_error("UID not specified for session %s", s->id);
 366                         return -ENOENT;
 367                 }
 368
 369                 r = parse_uid(uid, &u);
 370                 if (r < 0)  {
 371                         log_error("Failed to parse UID value %s for session %s.", uid, s->id);
 372                         return r;
 373                 }
 374
 375                 user = hashmap_get(s->manager->users, UID_TO_PTR(u));
 376                 if (!user) {
 377                         log_error("User of session %s not known.", s->id);
 378                         return -ENOENT;
 379                 }
 380
 381                 session_set_user(s, user);
 382         }
 383
 384         if (remote) {
 385                 k = parse_boolean(remote);
 386                 if (k >= 0)
 387                         s->remote = k;
 388         }
 389
 390         if (vtnr)
 391                 safe_atou(vtnr, &s->vtnr);
 392
 393         if (seat && !s->seat) {
 394                 Seat *o;
 395
 396                 o = hashmap_get(s->manager->seats, seat);
 397                 if (o)
 398                         r = seat_attach_session(o, s);
 399                 if (!o || r < 0)
 400                         log_error("Cannot attach session %s to seat %s", s->id, seat);
 401         }
 402
 403         if (!s->seat || !seat_has_vts(s->seat))
 404                 s->vtnr = 0;
 405
 406         if (position && s->seat) {
 407                 unsigned int npos;
 408
 409                 safe_atou(position, &npos);
 410                 seat_claim_position(s->seat, s, npos);
 411         }
 412
 413         if (leader) {
 414                 k = parse_pid(leader, &s->leader);
 415                 if (k >= 0)
 416                         audit_session_from_pid(s->leader, &s->audit_id);
 417         }
 418
 419         if (type) {
 420                 SessionType t;
 421
 422                 t = session_type_from_string(type);
 423                 if (t >= 0)
 424                         s->type = t;
 425         }
 426
 427         if (class) {
 428                 SessionClass c;
 429
 430                 c = session_class_from_string(class);
 431                 if (c >= 0)
 432                         s->class = c;
 433         }
 434
 435         if (state && streq(state, "closing"))
 436                 s->stopping = true;
 437
 438         if (s->fifo_path) {
 439                 int fd;
 440
 441                 /* If we open an unopened pipe for reading we will not
 442                    get an EOF. to trigger an EOF we hence open it for
 443                    writing, but close it right away which then will
 444                    trigger the EOF. This will happen immediately if no
 445                    other process has the FIFO open for writing, i. e.
 446                    when the session died before logind (re)started. */
 447
 448                 fd = session_create_fifo(s);
 449                 safe_close(fd);
 450         }
 451
 452         if (realtime) {
 453                 unsigned long long l;
 454                 if (sscanf(realtime, "%llu", &l) > 0)
 455                         s->timestamp.realtime = l;
 456         }
 457
 458         if (monotonic) {
 459                 unsigned long long l;
 460                 if (sscanf(monotonic, "%llu", &l) > 0)
 461                         s->timestamp.monotonic = l;
 462         }
 463
 464         if (controller) {
 465                 if (bus_name_has_owner(s->manager->bus, controller, NULL) > 0)
 466                         session_set_controller(s, controller, false);
 467                 else
 468                         session_restore_vt(s);
 469         }
 470
 471         return r;
 472 }
 473
 474 int session_activate(Session *s) {
 475         unsigned int num_pending;
 476
 477         assert(s);
 478         assert(s->user);
 479
 480         if (!s->seat)
 481                 return -EOPNOTSUPP;
 482
 483         if (s->seat->active == s)
 484                 return 0;
 485
 486         /* on seats with VTs, we let VTs manage session-switching */
 487         if (seat_has_vts(s->seat)) {
 488                 if (!s->vtnr)
 489                         return -EOPNOTSUPP;
 490
 491                 return chvt(s->vtnr);
 492         }
 493
 494         /* On seats without VTs, we implement session-switching in logind. We
 495          * try to pause all session-devices and wait until the session
 496          * controller acknowledged them. Once all devices are asleep, we simply
 497          * switch the active session and be done.
 498          * We save the session we want to switch to in seat->pending_switch and
 499          * seat_complete_switch() will perform the final switch. */
 500
 501         s->seat->pending_switch = s;
 502
 503         /* if no devices are running, immediately perform the session switch */
 504         num_pending = session_device_try_pause_all(s);
 505         if (!num_pending)
 506                 seat_complete_switch(s->seat);
 507
 508         return 0;
 509 }
 510
 511 /// UNNEEDED by elogind
 512 #if 0
 513 static int session_start_scope(Session *s) {
 514         int r = 0;
 515
 516         assert(s);
 517         assert(s->user);
 518         assert(s->user->slice);
 519
 520         if (!s->scope) {
 521                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 522                 _cleanup_free_ char *description = NULL;
 523                 char *scope = NULL; //, *job = NULL;
 524
 525                 description = strjoin("Session ", s->id, " of user ", s->user->name, NULL);
 526                 if (!description)
 527                         return log_oom();
 528
 529                 scope = strjoin("session-", s->id, ".scope", NULL);
 530                 if (!scope)
 531                         return log_oom();
 532
 533                 r = manager_start_scope(s->manager, scope, s->leader, s->user->slice, description, "logind.service", "systemd-user-sessions.service", &error, &job);
 534                 if (r < 0) {
 535                         log_error("Failed to start session scope %s: %s %s",
 536                                   scope, bus_error_message(&error, r), error.name);
 537                         free(scope);
 538                         return r;
 539                 } else {
 540                         s->scope = scope;
 541                         free(s->scope_job);
 542                         s->scope_job = job;
 543                 }
 544         }
 545
 546         if (s->scope)
 547                 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 /// UNNEEDED by elogind
 637 #if 0
 638 static int session_stop_scope(Session *s, bool force) {
 639         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 640         char *job = NULL;
 641         int r;
 642
 643         assert(s);
 644
 645         if (!s->scope)
 646                 return 0;
 647
 648         if (force || manager_shall_kill(s->manager, s->user->name)) {
 649                 r = manager_stop_unit(s->manager, s->scope, &error, &job);
 650                 if (r < 0) {
 651                         log_error("Failed to stop session scope: %s", bus_error_message(&error, r));
 652                         return r;
 653                 }
 654
 655                 free(s->scope_job);
 656                 s->scope_job = job;
 657         } else {
 658                 r = manager_abandon_scope(s->manager, s->scope, &error);
 659                 if (r < 0) {
 660                         log_error("Failed to abandon session scope: %s", bus_error_message(&error, r));
 661                         return r;
 662                 }
 663         }
 664
 665         return 0;
 666 }
 667 #endif // 0
 668
 669 static int session_stop_cgroup(Session *s, bool force) {
 670         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 671         int r;
 672
 673         assert(s);
 674
 675         if (force || manager_shall_kill(s->manager, s->user->name)) {
 676                 r = session_kill(s, KILL_ALL, SIGTERM);
 677                 if (r < 0)
 678                         return r;
 679         }
 680
 681         return 0;
 682 }
 683
 684 int session_stop(Session *s, bool force) {
 685         int r;
 686
 687         assert(s);
 688
 689         if (!s->user)
 690                 return -ESTALE;
 691
 692         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 693
 694         if (s->seat)
 695                 seat_evict_position(s->seat, s);
 696
 697         /* We are going down, don't care about FIFOs anymore */
 698         session_remove_fifo(s);
 699
 700         /* Kill cgroup */
 701 /// elogind does not start scopes, but sessions
 702 #if 0
 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 /// UNNEEDED by elogind
 768 #if 0
 769 static int release_timeout_callback(sd_event_source *es, uint64_t usec, void *userdata) {
 770         Session *s = userdata;
 771
 772         assert(es);
 773         assert(s);
 774
 775         session_stop(s, false);
 776         return 0;
 777 }
 778 #endif // 0
 779
 780 int session_release(Session *s) {
 781         assert(s);
 782
 783         if (!s->started || s->stopping)
 784                 return 0;
 785
 786         if (s->timer_event_source)
 787                 return 0;
 788
 789         /* In systemd, session release is triggered by user jobs
 790            dying.  In elogind we don't have that so go ahead and stop
 791            now.  */
 792 #if 0
 793         return sd_event_add_time(s->manager->event,
 794                                  &s->timer_event_source,
 795                                  CLOCK_MONOTONIC,
 796                                  now(CLOCK_MONOTONIC) + RELEASE_USEC, 0,
 797                                  release_timeout_callback, s);
 798
 799 #else
 800         return session_stop(s, false);
 801 #endif // 0
 802 }
 803
 804 bool session_is_active(Session *s) {
 805         assert(s);
 806
 807         if (!s->seat)
 808                 return true;
 809
 810         return s->seat->active == s;
 811 }
 812
 813 static int get_tty_atime(const char *tty, usec_t *atime) {
 814         _cleanup_free_ char *p = NULL;
 815         struct stat st;
 816
 817         assert(tty);
 818         assert(atime);
 819
 820         if (!path_is_absolute(tty)) {
 821                 p = strappend("/dev/", tty);
 822                 if (!p)
 823                         return -ENOMEM;
 824
 825                 tty = p;
 826         } else if (!path_startswith(tty, "/dev/"))
 827                 return -ENOENT;
 828
 829         if (lstat(tty, &st) < 0)
 830                 return -errno;
 831
 832         *atime = timespec_load(&st.st_atim);
 833         return 0;
 834 }
 835
 836 static int get_process_ctty_atime(pid_t pid, usec_t *atime) {
 837         _cleanup_free_ char *p = NULL;
 838         int r;
 839
 840         assert(pid > 0);
 841         assert(atime);
 842
 843         r = get_ctty(pid, NULL, &p);
 844         if (r < 0)
 845                 return r;
 846
 847         return get_tty_atime(p, atime);
 848 }
 849
 850 int session_get_idle_hint(Session *s, dual_timestamp *t) {
 851         usec_t atime = 0, n;
 852         int r;
 853
 854         assert(s);
 855
 856         /* Explicit idle hint is set */
 857         if (s->idle_hint) {
 858                 if (t)
 859                         *t = s->idle_hint_timestamp;
 860
 861                 return s->idle_hint;
 862         }
 863
 864         /* Graphical sessions should really implement a real
 865          * idle hint logic */
 866         if (s->display)
 867                 goto dont_know;
 868
 869         /* For sessions with an explicitly configured tty, let's check
 870          * its atime */
 871         if (s->tty) {
 872                 r = get_tty_atime(s->tty, &atime);
 873                 if (r >= 0)
 874                         goto found_atime;
 875         }
 876
 877         /* For sessions with a leader but no explicitly configured
 878          * tty, let's check the controlling tty of the leader */
 879         if (s->leader > 0) {
 880                 r = get_process_ctty_atime(s->leader, &atime);
 881                 if (r >= 0)
 882                         goto found_atime;
 883         }
 884
 885 dont_know:
 886         if (t)
 887                 *t = s->idle_hint_timestamp;
 888
 889         return 0;
 890
 891 found_atime:
 892         if (t)
 893                 dual_timestamp_from_realtime(t, atime);
 894
 895         n = now(CLOCK_REALTIME);
 896
 897         if (s->manager->idle_action_usec <= 0)
 898                 return 0;
 899
 900         return atime + s->manager->idle_action_usec <= n;
 901 }
 902
 903 void session_set_idle_hint(Session *s, bool b) {
 904         assert(s);
 905
 906         if (s->idle_hint == b)
 907                 return;
 908
 909         s->idle_hint = b;
 910         dual_timestamp_get(&s->idle_hint_timestamp);
 911
 912         session_send_changed(s, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
 913
 914         if (s->seat)
 915                 seat_send_changed(s->seat, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
 916
 917         user_send_changed(s->user, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
 918         manager_send_changed(s->manager, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
 919 }
 920
 921 static int session_dispatch_fifo(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
 922         Session *s = userdata;
 923
 924         assert(s);
 925         assert(s->fifo_fd == fd);
 926
 927         /* EOF on the FIFO means the session died abnormally. */
 928
 929         session_remove_fifo(s);
 930         session_stop(s, false);
 931
 932         return 1;
 933 }
 934
 935 int session_create_fifo(Session *s) {
 936         int r;
 937
 938         assert(s);
 939
 940         /* Create FIFO */
 941         if (!s->fifo_path) {
 942                 r = mkdir_safe_label("/run/systemd/sessions", 0755, 0, 0);
 943                 if (r < 0)
 944                         return r;
 945
 946                 if (asprintf(&s->fifo_path, "/run/systemd/sessions/%s.ref", s->id) < 0)
 947                         return -ENOMEM;
 948
 949                 if (mkfifo(s->fifo_path, 0600) < 0 && errno != EEXIST)
 950                         return -errno;
 951         }
 952
 953         /* Open reading side */
 954         if (s->fifo_fd < 0) {
 955                 s->fifo_fd = open(s->fifo_path, O_RDONLY|O_CLOEXEC|O_NDELAY);
 956                 if (s->fifo_fd < 0)
 957                         return -errno;
 958
 959         }
 960
 961         if (!s->fifo_event_source) {
 962                 r = sd_event_add_io(s->manager->event, &s->fifo_event_source, s->fifo_fd, 0, session_dispatch_fifo, s);
 963                 if (r < 0)
 964                         return r;
 965
 966                 r = sd_event_source_set_priority(s->fifo_event_source, SD_EVENT_PRIORITY_IDLE);
 967                 if (r < 0)
 968                         return r;
 969         }
 970
 971         /* Open writing side */
 972         r = open(s->fifo_path, O_WRONLY|O_CLOEXEC|O_NDELAY);
 973         if (r < 0)
 974                 return -errno;
 975
 976         return r;
 977 }
 978
 979 static void session_remove_fifo(Session *s) {
 980         assert(s);
 981
 982         s->fifo_event_source = sd_event_source_unref(s->fifo_event_source);
 983         s->fifo_fd = safe_close(s->fifo_fd);
 984
 985         if (s->fifo_path) {
 986                 unlink(s->fifo_path);
 987                 s->fifo_path = mfree(s->fifo_path);
 988         }
 989 }
 990
 991 bool session_check_gc(Session *s, bool drop_not_started) {
 992         assert(s);
 993
 994         if (drop_not_started && !s->started)
 995                 return false;
 996
 997         if (!s->user)
 998                 return false;
 999
1000         if (s->fifo_fd >= 0) {
1001                 if (pipe_eof(s->fifo_fd) <= 0)
1002                         return true;
1003         }
1004
1005 /// elogind supports neither scopes nor jobs
1006 #if 0
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 /// elogind does not support systemd scope_jobs
1039 #if 0
1040         if (s->scope_job || s->fifo_fd < 0)
1041 #else
1042         if (s->fifo_fd < 0)
1043 #endif // 0
1044                 return SESSION_OPENING;
1045
1046         if (session_is_active(s))
1047                 return SESSION_ACTIVE;
1048
1049         return SESSION_ONLINE;
1050 }
1051
1052 int session_kill(Session *s, KillWho who, int signo) {
1053         assert(s);
1054
1055 /// Without direct cgroup support, elogind can not kill sessions
1056 #if 0
1057         if (!s->scope)
1058                 return -ESRCH;
1059
1060         return manager_kill_unit(s->manager, s->scope, who, signo, NULL);
1061 #else
1062         if (who == KILL_LEADER) {
1063                 if (s->leader <= 0)
1064                         return -ESRCH;
1065
1066                 /* FIXME: verify that leader is in cgroup?  */
1067
1068                 if (kill(s->leader, signo) < 0) {
1069                         return log_error_errno(errno, "Failed to kill process leader %d for session %s: %m", s->leader, s->id);
1070                 }
1071                 return 0;
1072         } else {
1073                 bool sigcont = false;
1074                 bool ignore_self = true;
1075                 bool rem = true;
1076                 return cg_kill_recursive (SYSTEMD_CGROUP_CONTROLLER, s->id, signo,
1077                                           sigcont, ignore_self, rem, NULL);
1078         }
1079 #endif // 0
1080 }
1081
1082 static int session_open_vt(Session *s) {
1083         char path[sizeof("/dev/tty") + DECIMAL_STR_MAX(s->vtnr)];
1084
1085         if (s->vtnr < 1)
1086                 return -ENODEV;
1087
1088         if (s->vtfd >= 0)
1089                 return s->vtfd;
1090
1091         sprintf(path, "/dev/tty%u", s->vtnr);
1092         s->vtfd = open_terminal(path, O_RDWR | O_CLOEXEC | O_NONBLOCK | O_NOCTTY);
1093         if (s->vtfd < 0)
1094                 return log_error_errno(errno, "cannot open VT %s of session %s: %m", path, s->id);
1095
1096         return s->vtfd;
1097 }
1098
1099 int session_prepare_vt(Session *s) {
1100         int vt, r;
1101         struct vt_mode mode = { 0 };
1102
1103         if (s->vtnr < 1)
1104                 return 0;
1105
1106         vt = session_open_vt(s);
1107         if (vt < 0)
1108                 return vt;
1109
1110         r = fchown(vt, s->user->uid, -1);
1111         if (r < 0) {
1112                 r = -errno;
1113                 log_error_errno(errno, "Cannot change owner of /dev/tty%u: %m", s->vtnr);
1114                 goto error;
1115         }
1116
1117         r = ioctl(vt, KDSKBMODE, K_OFF);
1118         if (r < 0) {
1119                 r = -errno;
1120                 log_error_errno(errno, "Cannot set K_OFF on /dev/tty%u: %m", s->vtnr);
1121                 goto error;
1122         }
1123
1124         r = ioctl(vt, KDSETMODE, KD_GRAPHICS);
1125         if (r < 0) {
1126                 r = -errno;
1127                 log_error_errno(errno, "Cannot set KD_GRAPHICS on /dev/tty%u: %m", s->vtnr);
1128                 goto error;
1129         }
1130
1131         /* Oh, thanks to the VT layer, VT_AUTO does not work with KD_GRAPHICS.
1132          * So we need a dummy handler here which just acknowledges *all* VT
1133          * switch requests. */
1134         mode.mode = VT_PROCESS;
1135         mode.relsig = SIGRTMIN;
1136         mode.acqsig = SIGRTMIN + 1;
1137         r = ioctl(vt, VT_SETMODE, &mode);
1138         if (r < 0) {
1139                 r = -errno;
1140                 log_error_errno(errno, "Cannot set VT_PROCESS on /dev/tty%u: %m", 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         _cleanup_free_ char *utf8 = NULL;
1153         int vt, kb = K_XLATE;
1154         struct vt_mode mode = { 0 };
1155
1156         /* We need to get a fresh handle to the virtual terminal,
1157          * since the old file-descriptor is potentially in a hung-up
1158          * state after the controlling process exited; we do a
1159          * little dance to avoid having the terminal be available
1160          * for reuse before we've cleaned it up.
1161          */
1162         int old_fd = s->vtfd;
1163         s->vtfd = -1;
1164
1165         vt = session_open_vt(s);
1166         safe_close(old_fd);
1167
1168         if (vt < 0)
1169                 return;
1170
1171         (void) ioctl(vt, KDSETMODE, KD_TEXT);
1172
1173         if (read_one_line_file("/sys/module/vt/parameters/default_utf8", &utf8) >= 0 && *utf8 == '1')
1174                 kb = K_UNICODE;
1175
1176         (void) ioctl(vt, KDSKBMODE, kb);
1177
1178         mode.mode = VT_AUTO;
1179         (void) ioctl(vt, VT_SETMODE, &mode);
1180
1181         fchown(vt, 0, -1);
1182
1183         s->vtfd = safe_close(s->vtfd);
1184 }
1185
1186 void session_leave_vt(Session *s) {
1187         int r;
1188
1189         assert(s);
1190
1191         /* This is called whenever we get a VT-switch signal from the kernel.
1192          * We acknowledge all of them unconditionally. Note that session are
1193          * free to overwrite those handlers and we only register them for
1194          * sessions with controllers. Legacy sessions are not affected.
1195          * However, if we switch from a non-legacy to a legacy session, we must
1196          * make sure to pause all device before acknowledging the switch. We
1197          * process the real switch only after we are notified via sysfs, so the
1198          * legacy session might have already started using the devices. If we
1199          * don't pause the devices before the switch, we might confuse the
1200          * session we switch to. */
1201
1202         if (s->vtfd < 0)
1203                 return;
1204
1205         session_device_pause_all(s);
1206         r = ioctl(s->vtfd, VT_RELDISP, 1);
1207         if (r < 0)
1208                 log_debug_errno(errno, "Cannot release VT of session %s: %m", s->id);
1209 }
1210
1211 bool session_is_controller(Session *s, const char *sender) {
1212         assert(s);
1213
1214         return streq_ptr(s->controller, sender);
1215 }
1216
1217 static void session_release_controller(Session *s, bool notify) {
1218         _cleanup_free_ char *name = NULL;
1219         SessionDevice *sd;
1220
1221         if (!s->controller)
1222                 return;
1223
1224         name = s->controller;
1225
1226         /* By resetting the controller before releasing the devices, we won't
1227          * send notification signals. This avoids sending useless notifications
1228          * if the controller is released on disconnects. */
1229         if (!notify)
1230                 s->controller = NULL;
1231
1232         while ((sd = hashmap_first(s->devices)))
1233                 session_device_free(sd);
1234
1235         s->controller = NULL;
1236         s->track = sd_bus_track_unref(s->track);
1237 }
1238
1239 static int on_bus_track(sd_bus_track *track, void *userdata) {
1240         Session *s = userdata;
1241
1242         assert(track);
1243         assert(s);
1244
1245         session_drop_controller(s);
1246
1247         return 0;
1248 }
1249
1250 int session_set_controller(Session *s, const char *sender, bool force) {
1251         _cleanup_free_ char *name = NULL;
1252         int r;
1253
1254         assert(s);
1255         assert(sender);
1256
1257         if (session_is_controller(s, sender))
1258                 return 0;
1259         if (s->controller && !force)
1260                 return -EBUSY;
1261
1262         name = strdup(sender);
1263         if (!name)
1264                 return -ENOMEM;
1265
1266         s->track = sd_bus_track_unref(s->track);
1267         r = sd_bus_track_new(s->manager->bus, &s->track, on_bus_track, s);
1268         if (r < 0)
1269                 return r;
1270
1271         r = sd_bus_track_add_name(s->track, name);
1272         if (r < 0)
1273                 return r;
1274
1275         /* When setting a session controller, we forcibly mute the VT and set
1276          * it into graphics-mode. Applications can override that by changing
1277          * VT state after calling TakeControl(). However, this serves as a good
1278          * default and well-behaving controllers can now ignore VTs entirely.
1279          * Note that we reset the VT on ReleaseControl() and if the controller
1280          * exits.
1281          * If logind crashes/restarts, we restore the controller during restart
1282          * or reset the VT in case it crashed/exited, too. */
1283         r = session_prepare_vt(s);
1284         if (r < 0) {
1285                 s->track = sd_bus_track_unref(s->track);
1286                 return r;
1287         }
1288
1289         session_release_controller(s, true);
1290         s->controller = name;
1291         name = NULL;
1292         session_save(s);
1293
1294         return 0;
1295 }
1296
1297 void session_drop_controller(Session *s) {
1298         assert(s);
1299
1300         if (!s->controller)
1301                 return;
1302
1303         s->track = sd_bus_track_unref(s->track);
1304         session_release_controller(s, false);
1305         session_save(s);
1306         session_restore_vt(s);
1307 }
1308
1309 static const char* const session_state_table[_SESSION_STATE_MAX] = {
1310         [SESSION_OPENING] = "opening",
1311         [SESSION_ONLINE] = "online",
1312         [SESSION_ACTIVE] = "active",
1313         [SESSION_CLOSING] = "closing"
1314 };
1315
1316 DEFINE_STRING_TABLE_LOOKUP(session_state, SessionState);
1317
1318 static const char* const session_type_table[_SESSION_TYPE_MAX] = {
1319         [SESSION_UNSPECIFIED] = "unspecified",
1320         [SESSION_TTY] = "tty",
1321         [SESSION_X11] = "x11",
1322         [SESSION_WAYLAND] = "wayland",
1323         [SESSION_MIR] = "mir",
1324         [SESSION_WEB] = "web",
1325 };
1326
1327 DEFINE_STRING_TABLE_LOOKUP(session_type, SessionType);
1328
1329 static const char* const session_class_table[_SESSION_CLASS_MAX] = {
1330         [SESSION_USER] = "user",
1331         [SESSION_GREETER] = "greeter",
1332         [SESSION_LOCK_SCREEN] = "lock-screen",
1333         [SESSION_BACKGROUND] = "background"
1334 };
1335
1336 DEFINE_STRING_TABLE_LOOKUP(session_class, SessionClass);
1337
1338 static const char* const kill_who_table[_KILL_WHO_MAX] = {
1339         [KILL_LEADER] = "leader",
1340         [KILL_ALL] = "all"
1341 };
1342
1343 DEFINE_STRING_TABLE_LOOKUP(kill_who, KillWho);