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         sd_bus_message_unref(s->create_message);
 124
 125         free(s->tty);
 126         free(s->display);
 127         free(s->remote_host);
 128         free(s->remote_user);
 129         free(s->service);
 130         free(s->desktop);
 131
 132         hashmap_remove(s->manager->sessions, s->id);
 133
 134         free(s->state_file);
 135         free(s);
 136 }
 137
 138 void session_set_user(Session *s, User *u) {
 139         assert(s);
 140         assert(!s->user);
 141
 142         s->user = u;
 143         LIST_PREPEND(sessions_by_user, u->sessions, s);
 144 }
 145
 146 int session_save(Session *s) {
 147         _cleanup_free_ char *temp_path = NULL;
 148         _cleanup_fclose_ FILE *f = NULL;
 149         int r = 0;
 150
 151         assert(s);
 152
 153         if (!s->user)
 154                 return -ESTALE;
 155
 156         if (!s->started)
 157                 return 0;
 158
 159         r = mkdir_safe_label("/run/systemd/sessions", 0755, 0, 0);
 160         if (r < 0)
 161                 goto finish;
 162
 163         r = fopen_temporary(s->state_file, &f, &temp_path);
 164         if (r < 0)
 165                 goto finish;
 166
 167         assert(s->user);
 168
 169         fchmod(fileno(f), 0644);
 170
 171         fprintf(f,
 172                 "# This is private data. Do not parse.\n"
 173                 "UID="UID_FMT"\n"
 174                 "USER=%s\n"
 175                 "ACTIVE=%i\n"
 176                 "STATE=%s\n"
 177                 "REMOTE=%i\n",
 178                 s->user->uid,
 179                 s->user->name,
 180                 session_is_active(s),
 181                 session_state_to_string(session_get_state(s)),
 182                 s->remote);
 183
 184         if (s->type >= 0)
 185                 fprintf(f, "TYPE=%s\n", session_type_to_string(s->type));
 186
 187         if (s->class >= 0)
 188                 fprintf(f, "CLASS=%s\n", session_class_to_string(s->class));
 189
 190         if (s->fifo_path)
 191                 fprintf(f, "FIFO=%s\n", s->fifo_path);
 192
 193         if (s->seat)
 194                 fprintf(f, "SEAT=%s\n", s->seat->id);
 195
 196         if (s->tty)
 197                 fprintf(f, "TTY=%s\n", s->tty);
 198
 199         if (s->display)
 200                 fprintf(f, "DISPLAY=%s\n", s->display);
 201
 202         if (s->remote_host) {
 203                 _cleanup_free_ char *escaped;
 204
 205                 escaped = cescape(s->remote_host);
 206                 if (!escaped) {
 207                         r = -ENOMEM;
 208                         goto finish;
 209                 }
 210
 211                 fprintf(f, "REMOTE_HOST=%s\n", escaped);
 212         }
 213
 214         if (s->remote_user) {
 215                 _cleanup_free_ char *escaped;
 216
 217                 escaped = cescape(s->remote_user);
 218                 if (!escaped) {
 219                         r = -ENOMEM;
 220                         goto finish;
 221                 }
 222
 223                 fprintf(f, "REMOTE_USER=%s\n", escaped);
 224         }
 225
 226         if (s->service) {
 227                 _cleanup_free_ char *escaped;
 228
 229                 escaped = cescape(s->service);
 230                 if (!escaped) {
 231                         r = -ENOMEM;
 232                         goto finish;
 233                 }
 234
 235                 fprintf(f, "SERVICE=%s\n", escaped);
 236         }
 237
 238         if (s->desktop) {
 239                 _cleanup_free_ char *escaped;
 240
 241
 242                 escaped = cescape(s->desktop);
 243                 if (!escaped) {
 244                         r = -ENOMEM;
 245                         goto finish;
 246                 }
 247
 248                 fprintf(f, "DESKTOP=%s\n", escaped);
 249         }
 250
 251         if (s->seat && seat_has_vts(s->seat))
 252                 fprintf(f, "VTNR=%u\n", s->vtnr);
 253
 254         if (!s->vtnr)
 255                 fprintf(f, "POSITION=%u\n", s->position);
 256
 257         if (s->leader > 0)
 258                 fprintf(f, "LEADER="PID_FMT"\n", s->leader);
 259
 260         if (s->audit_id > 0)
 261                 fprintf(f, "AUDIT=%"PRIu32"\n", s->audit_id);
 262
 263         if (dual_timestamp_is_set(&s->timestamp))
 264                 fprintf(f,
 265                         "REALTIME="USEC_FMT"\n"
 266                         "MONOTONIC="USEC_FMT"\n",
 267                         s->timestamp.realtime,
 268                         s->timestamp.monotonic);
 269
 270         if (s->controller)
 271                 fprintf(f, "CONTROLLER=%s\n", s->controller);
 272
 273         fflush(f);
 274
 275         if (ferror(f) || rename(temp_path, s->state_file) < 0) {
 276                 r = -errno;
 277                 unlink(s->state_file);
 278                 unlink(temp_path);
 279         }
 280
 281 finish:
 282         if (r < 0)
 283                 log_error_errno(r, "Failed to save session data %s: %m", s->state_file);
 284
 285         return r;
 286 }
 287
 288 int session_load(Session *s) {
 289         _cleanup_free_ char *remote = NULL,
 290                 *seat = NULL,
 291                 *vtnr = NULL,
 292                 *state = NULL,
 293                 *position = NULL,
 294                 *leader = NULL,
 295                 *type = NULL,
 296                 *class = NULL,
 297                 *uid = NULL,
 298                 *realtime = NULL,
 299                 *monotonic = NULL,
 300                 *controller = NULL;
 301
 302         int k, r;
 303
 304         assert(s);
 305
 306         r = parse_env_file(s->state_file, NEWLINE,
 307                            "REMOTE",         &remote,
 308                            "FIFO",           &s->fifo_path,
 309                            "SEAT",           &seat,
 310                            "TTY",            &s->tty,
 311                            "DISPLAY",        &s->display,
 312                            "REMOTE_HOST",    &s->remote_host,
 313                            "REMOTE_USER",    &s->remote_user,
 314                            "SERVICE",        &s->service,
 315                            "DESKTOP",        &s->desktop,
 316                            "VTNR",           &vtnr,
 317                            "STATE",          &state,
 318                            "POSITION",       &position,
 319                            "LEADER",         &leader,
 320                            "TYPE",           &type,
 321                            "CLASS",          &class,
 322                            "UID",            &uid,
 323                            "REALTIME",       &realtime,
 324                            "MONOTONIC",      &monotonic,
 325                            "CONTROLLER",     &controller,
 326                            NULL);
 327
 328         if (r < 0)
 329                 return log_error_errno(r, "Failed to read %s: %m", s->state_file);
 330
 331         if (!s->user) {
 332                 uid_t u;
 333                 User *user;
 334
 335                 if (!uid) {
 336                         log_error("UID not specified for session %s", s->id);
 337                         return -ENOENT;
 338                 }
 339
 340                 r = parse_uid(uid, &u);
 341                 if (r < 0)  {
 342                         log_error("Failed to parse UID value %s for session %s.", uid, s->id);
 343                         return r;
 344                 }
 345
 346                 user = hashmap_get(s->manager->users, UID_TO_PTR(u));
 347                 if (!user) {
 348                         log_error("User of session %s not known.", s->id);
 349                         return -ENOENT;
 350                 }
 351
 352                 session_set_user(s, user);
 353         }
 354
 355         if (remote) {
 356                 k = parse_boolean(remote);
 357                 if (k >= 0)
 358                         s->remote = k;
 359         }
 360
 361         if (vtnr)
 362                 safe_atou(vtnr, &s->vtnr);
 363
 364         if (seat && !s->seat) {
 365                 Seat *o;
 366
 367                 o = hashmap_get(s->manager->seats, seat);
 368                 if (o)
 369                         r = seat_attach_session(o, s);
 370                 if (!o || r < 0)
 371                         log_error("Cannot attach session %s to seat %s", s->id, seat);
 372         }
 373
 374         if (!s->seat || !seat_has_vts(s->seat))
 375                 s->vtnr = 0;
 376
 377         if (position && s->seat) {
 378                 unsigned int npos;
 379
 380                 safe_atou(position, &npos);
 381                 seat_claim_position(s->seat, s, npos);
 382         }
 383
 384         if (leader) {
 385                 k = parse_pid(leader, &s->leader);
 386                 if (k >= 0)
 387                         audit_session_from_pid(s->leader, &s->audit_id);
 388         }
 389
 390         if (type) {
 391                 SessionType t;
 392
 393                 t = session_type_from_string(type);
 394                 if (t >= 0)
 395                         s->type = t;
 396         }
 397
 398         if (class) {
 399                 SessionClass c;
 400
 401                 c = session_class_from_string(class);
 402                 if (c >= 0)
 403                         s->class = c;
 404         }
 405
 406         if (state && streq(state, "closing"))
 407                 s->stopping = true;
 408
 409         if (s->fifo_path) {
 410                 int fd;
 411
 412                 /* If we open an unopened pipe for reading we will not
 413                    get an EOF. to trigger an EOF we hence open it for
 414                    writing, but close it right away which then will
 415                    trigger the EOF. This will happen immediately if no
 416                    other process has the FIFO open for writing, i. e.
 417                    when the session died before logind (re)started. */
 418
 419                 fd = session_create_fifo(s);
 420                 safe_close(fd);
 421         }
 422
 423         if (realtime) {
 424                 unsigned long long l;
 425                 if (sscanf(realtime, "%llu", &l) > 0)
 426                         s->timestamp.realtime = l;
 427         }
 428
 429         if (monotonic) {
 430                 unsigned long long l;
 431                 if (sscanf(monotonic, "%llu", &l) > 0)
 432                         s->timestamp.monotonic = l;
 433         }
 434
 435         if (controller) {
 436                 if (bus_name_has_owner(s->manager->bus, controller, NULL) > 0)
 437                         session_set_controller(s, controller, false);
 438                 else
 439                         session_restore_vt(s);
 440         }
 441
 442         return r;
 443 }
 444
 445 int session_activate(Session *s) {
 446         unsigned int num_pending;
 447
 448         assert(s);
 449         assert(s->user);
 450
 451         if (!s->seat)
 452                 return -EOPNOTSUPP;
 453
 454         if (s->seat->active == s)
 455                 return 0;
 456
 457         /* on seats with VTs, we let VTs manage session-switching */
 458         if (seat_has_vts(s->seat)) {
 459                 if (!s->vtnr)
 460                         return -EOPNOTSUPP;
 461
 462                 return chvt(s->vtnr);
 463         }
 464
 465         /* On seats without VTs, we implement session-switching in logind. We
 466          * try to pause all session-devices and wait until the session
 467          * controller acknowledged them. Once all devices are asleep, we simply
 468          * switch the active session and be done.
 469          * We save the session we want to switch to in seat->pending_switch and
 470          * seat_complete_switch() will perform the final switch. */
 471
 472         s->seat->pending_switch = s;
 473
 474         /* if no devices are running, immediately perform the session switch */
 475         num_pending = session_device_try_pause_all(s);
 476         if (!num_pending)
 477                 seat_complete_switch(s->seat);
 478
 479         return 0;
 480 }
 481
 482 int session_start(Session *s) {
 483         int r;
 484
 485         assert(s);
 486
 487         if (!s->user)
 488                 return -ESTALE;
 489
 490         if (s->started)
 491                 return 0;
 492
 493         r = user_start(s->user);
 494         if (r < 0)
 495                 return r;
 496
 497         log_struct(s->class == SESSION_BACKGROUND ? LOG_DEBUG : LOG_INFO,
 498                    LOG_MESSAGE_ID(SD_MESSAGE_SESSION_START),
 499                    "SESSION_ID=%s", s->id,
 500                    "USER_ID=%s", s->user->name,
 501                    "LEADER="PID_FMT, s->leader,
 502                    LOG_MESSAGE("New session %s of user %s.", s->id, s->user->name),
 503                    NULL);
 504
 505         if (!dual_timestamp_is_set(&s->timestamp))
 506                 dual_timestamp_get(&s->timestamp);
 507
 508         if (s->seat)
 509                 seat_read_active_vt(s->seat);
 510
 511         s->started = true;
 512
 513         user_elect_display(s->user);
 514
 515         /* Save data */
 516         session_save(s);
 517         user_save(s->user);
 518         if (s->seat)
 519                 seat_save(s->seat);
 520
 521         /* Send signals */
 522         session_send_signal(s, true);
 523         user_send_changed(s->user, "Sessions", "Display", NULL);
 524         if (s->seat) {
 525                 if (s->seat->active == s)
 526                         seat_send_changed(s->seat, "Sessions", "ActiveSession", NULL);
 527                 else
 528                         seat_send_changed(s->seat, "Sessions", NULL);
 529         }
 530
 531         return 0;
 532 }
 533
 534 int session_stop(Session *s, bool force) {
 535         int r = 0;
 536
 537         assert(s);
 538
 539         if (!s->user)
 540                 return -ESTALE;
 541
 542         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 543
 544         if (s->seat)
 545                 seat_evict_position(s->seat, s);
 546
 547         /* We are going down, don't care about FIFOs anymore */
 548         session_remove_fifo(s);
 549
 550         s->stopping = true;
 551
 552         user_elect_display(s->user);
 553
 554         session_save(s);
 555         user_save(s->user);
 556
 557         return r;
 558 }
 559
 560 int session_finalize(Session *s) {
 561         int r = 0;
 562         SessionDevice *sd;
 563
 564         assert(s);
 565
 566         if (!s->user)
 567                 return -ESTALE;
 568
 569         if (s->started)
 570                 log_struct(s->class == SESSION_BACKGROUND ? LOG_DEBUG : LOG_INFO,
 571                            LOG_MESSAGE_ID(SD_MESSAGE_SESSION_STOP),
 572                            "SESSION_ID=%s", s->id,
 573                            "USER_ID=%s", s->user->name,
 574                            "LEADER="PID_FMT, s->leader,
 575                            LOG_MESSAGE("Removed session %s.", s->id),
 576                            NULL);
 577
 578         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 579
 580         if (s->seat)
 581                 seat_evict_position(s->seat, s);
 582
 583         /* Kill session devices */
 584         while ((sd = hashmap_first(s->devices)))
 585                 session_device_free(sd);
 586
 587         unlink(s->state_file);
 588         session_add_to_gc_queue(s);
 589         user_add_to_gc_queue(s->user);
 590
 591         if (s->started) {
 592                 session_send_signal(s, false);
 593                 s->started = false;
 594         }
 595
 596         if (s->seat) {
 597                 if (s->seat->active == s)
 598                         seat_set_active(s->seat, NULL);
 599
 600                 seat_save(s->seat);
 601                 seat_send_changed(s->seat, "Sessions", NULL);
 602         }
 603
 604         user_save(s->user);
 605         user_send_changed(s->user, "Sessions", "Display", NULL);
 606
 607         return r;
 608 }
 609
 610 static int release_timeout_callback(sd_event_source *es, uint64_t usec, void *userdata) {
 611         Session *s = userdata;
 612
 613         assert(es);
 614         assert(s);
 615
 616         session_stop(s, false);
 617         return 0;
 618 }
 619
 620 int session_release(Session *s) {
 621         assert(s);
 622
 623         if (!s->started || s->stopping)
 624                 return 0;
 625
 626         if (s->timer_event_source)
 627                 return 0;
 628
 629         return sd_event_add_time(s->manager->event,
 630                                  &s->timer_event_source,
 631                                  CLOCK_MONOTONIC,
 632                                  now(CLOCK_MONOTONIC) + RELEASE_USEC, 0,
 633                                  release_timeout_callback, s);
 634 }
 635
 636 bool session_is_active(Session *s) {
 637         assert(s);
 638
 639         if (!s->seat)
 640                 return true;
 641
 642         return s->seat->active == s;
 643 }
 644
 645 static int get_tty_atime(const char *tty, usec_t *atime) {
 646         _cleanup_free_ char *p = NULL;
 647         struct stat st;
 648
 649         assert(tty);
 650         assert(atime);
 651
 652         if (!path_is_absolute(tty)) {
 653                 p = strappend("/dev/", tty);
 654                 if (!p)
 655                         return -ENOMEM;
 656
 657                 tty = p;
 658         } else if (!path_startswith(tty, "/dev/"))
 659                 return -ENOENT;
 660
 661         if (lstat(tty, &st) < 0)
 662                 return -errno;
 663
 664         *atime = timespec_load(&st.st_atim);
 665         return 0;
 666 }
 667
 668 static int get_process_ctty_atime(pid_t pid, usec_t *atime) {
 669         _cleanup_free_ char *p = NULL;
 670         int r;
 671
 672         assert(pid > 0);
 673         assert(atime);
 674
 675         r = get_ctty(pid, NULL, &p);
 676         if (r < 0)
 677                 return r;
 678
 679         return get_tty_atime(p, atime);
 680 }
 681
 682 int session_get_idle_hint(Session *s, dual_timestamp *t) {
 683         usec_t atime = 0, n;
 684         int r;
 685
 686         assert(s);
 687
 688         /* Explicit idle hint is set */
 689         if (s->idle_hint) {
 690                 if (t)
 691                         *t = s->idle_hint_timestamp;
 692
 693                 return s->idle_hint;
 694         }
 695
 696         /* Graphical sessions should really implement a real
 697          * idle hint logic */
 698         if (s->display)
 699                 goto dont_know;
 700
 701         /* For sessions with an explicitly configured tty, let's check
 702          * its atime */
 703         if (s->tty) {
 704                 r = get_tty_atime(s->tty, &atime);
 705                 if (r >= 0)
 706                         goto found_atime;
 707         }
 708
 709         /* For sessions with a leader but no explicitly configured
 710          * tty, let's check the controlling tty of the leader */
 711         if (s->leader > 0) {
 712                 r = get_process_ctty_atime(s->leader, &atime);
 713                 if (r >= 0)
 714                         goto found_atime;
 715         }
 716
 717 dont_know:
 718         if (t)
 719                 *t = s->idle_hint_timestamp;
 720
 721         return 0;
 722
 723 found_atime:
 724         if (t)
 725                 dual_timestamp_from_realtime(t, atime);
 726
 727         n = now(CLOCK_REALTIME);
 728
 729         if (s->manager->idle_action_usec <= 0)
 730                 return 0;
 731
 732         return atime + s->manager->idle_action_usec <= n;
 733 }
 734
 735 void session_set_idle_hint(Session *s, bool b) {
 736         assert(s);
 737
 738         if (s->idle_hint == b)
 739                 return;
 740
 741         s->idle_hint = b;
 742         dual_timestamp_get(&s->idle_hint_timestamp);
 743
 744         session_send_changed(s, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
 745
 746         if (s->seat)
 747                 seat_send_changed(s->seat, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
 748
 749         user_send_changed(s->user, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
 750         manager_send_changed(s->manager, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
 751 }
 752
 753 static int session_dispatch_fifo(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
 754         Session *s = userdata;
 755
 756         assert(s);
 757         assert(s->fifo_fd == fd);
 758
 759         /* EOF on the FIFO means the session died abnormally. */
 760
 761         session_remove_fifo(s);
 762         session_stop(s, false);
 763
 764         return 1;
 765 }
 766
 767 int session_create_fifo(Session *s) {
 768         int r;
 769
 770         assert(s);
 771
 772         /* Create FIFO */
 773         if (!s->fifo_path) {
 774                 r = mkdir_safe_label("/run/systemd/sessions", 0755, 0, 0);
 775                 if (r < 0)
 776                         return r;
 777
 778                 if (asprintf(&s->fifo_path, "/run/systemd/sessions/%s.ref", s->id) < 0)
 779                         return -ENOMEM;
 780
 781                 if (mkfifo(s->fifo_path, 0600) < 0 && errno != EEXIST)
 782                         return -errno;
 783         }
 784
 785         /* Open reading side */
 786         if (s->fifo_fd < 0) {
 787                 s->fifo_fd = open(s->fifo_path, O_RDONLY|O_CLOEXEC|O_NDELAY);
 788                 if (s->fifo_fd < 0)
 789                         return -errno;
 790
 791         }
 792
 793         if (!s->fifo_event_source) {
 794                 r = sd_event_add_io(s->manager->event, &s->fifo_event_source, s->fifo_fd, 0, session_dispatch_fifo, s);
 795                 if (r < 0)
 796                         return r;
 797
 798                 r = sd_event_source_set_priority(s->fifo_event_source, SD_EVENT_PRIORITY_IDLE);
 799                 if (r < 0)
 800                         return r;
 801         }
 802
 803         /* Open writing side */
 804         r = open(s->fifo_path, O_WRONLY|O_CLOEXEC|O_NDELAY);
 805         if (r < 0)
 806                 return -errno;
 807
 808         return r;
 809 }
 810
 811 static void session_remove_fifo(Session *s) {
 812         assert(s);
 813
 814         s->fifo_event_source = sd_event_source_unref(s->fifo_event_source);
 815         s->fifo_fd = safe_close(s->fifo_fd);
 816
 817         if (s->fifo_path) {
 818                 unlink(s->fifo_path);
 819                 free(s->fifo_path);
 820                 s->fifo_path = NULL;
 821         }
 822 }
 823
 824 bool session_check_gc(Session *s, bool drop_not_started) {
 825         assert(s);
 826
 827         if (drop_not_started && !s->started)
 828                 return false;
 829
 830         if (!s->user)
 831                 return false;
 832
 833         if (s->fifo_fd >= 0) {
 834                 if (pipe_eof(s->fifo_fd) <= 0)
 835                         return true;
 836         }
 837
 838         return false;
 839 }
 840
 841 void session_add_to_gc_queue(Session *s) {
 842         assert(s);
 843
 844         if (s->in_gc_queue)
 845                 return;
 846
 847         LIST_PREPEND(gc_queue, s->manager->session_gc_queue, s);
 848         s->in_gc_queue = true;
 849 }
 850
 851 SessionState session_get_state(Session *s) {
 852         assert(s);
 853
 854         /* always check closing first */
 855         if (s->stopping || s->timer_event_source)
 856                 return SESSION_CLOSING;
 857
 858         if (s->fifo_fd < 0)
 859                 return SESSION_OPENING;
 860
 861         if (session_is_active(s))
 862                 return SESSION_ACTIVE;
 863
 864         return SESSION_ONLINE;
 865 }
 866
 867 int session_kill(Session *s, KillWho who, int signo) {
 868         assert(s);
 869
 870         /* No way to kill the session without cgroups.  */
 871         return -ESRCH;
 872 }
 873
 874 static int session_open_vt(Session *s) {
 875         char path[sizeof("/dev/tty") + DECIMAL_STR_MAX(s->vtnr)];
 876
 877         if (s->vtnr < 1)
 878                 return -ENODEV;
 879
 880         if (s->vtfd >= 0)
 881                 return s->vtfd;
 882
 883         sprintf(path, "/dev/tty%u", s->vtnr);
 884         s->vtfd = open(path, O_RDWR | O_CLOEXEC | O_NONBLOCK | O_NOCTTY);
 885         if (s->vtfd < 0)
 886                 return log_error_errno(errno, "cannot open VT %s of session %s: %m", path, s->id);
 887
 888         return s->vtfd;
 889 }
 890
 891 int session_prepare_vt(Session *s) {
 892         int vt, r;
 893         struct vt_mode mode = { 0 };
 894
 895         if (s->vtnr < 1)
 896                 return 0;
 897
 898         vt = session_open_vt(s);
 899         if (vt < 0)
 900                 return vt;
 901
 902         r = fchown(vt, s->user->uid, -1);
 903         if (r < 0) {
 904                 r = -errno;
 905                 log_error_errno(errno, "Cannot change owner of /dev/tty%u: %m", s->vtnr);
 906                 goto error;
 907         }
 908
 909         r = ioctl(vt, KDSKBMODE, K_OFF);
 910         if (r < 0) {
 911                 r = -errno;
 912                 log_error_errno(errno, "Cannot set K_OFF on /dev/tty%u: %m", s->vtnr);
 913                 goto error;
 914         }
 915
 916         r = ioctl(vt, KDSETMODE, KD_GRAPHICS);
 917         if (r < 0) {
 918                 r = -errno;
 919                 log_error_errno(errno, "Cannot set KD_GRAPHICS on /dev/tty%u: %m", s->vtnr);
 920                 goto error;
 921         }
 922
 923         /* Oh, thanks to the VT layer, VT_AUTO does not work with KD_GRAPHICS.
 924          * So we need a dummy handler here which just acknowledges *all* VT
 925          * switch requests. */
 926         mode.mode = VT_PROCESS;
 927         mode.relsig = SIGRTMIN;
 928         mode.acqsig = SIGRTMIN + 1;
 929         r = ioctl(vt, VT_SETMODE, &mode);
 930         if (r < 0) {
 931                 r = -errno;
 932                 log_error_errno(errno, "Cannot set VT_PROCESS on /dev/tty%u: %m", s->vtnr);
 933                 goto error;
 934         }
 935
 936         return 0;
 937
 938 error:
 939         session_restore_vt(s);
 940         return r;
 941 }
 942
 943 void session_restore_vt(Session *s) {
 944         _cleanup_free_ char *utf8 = NULL;
 945         int vt, kb = K_XLATE;
 946         struct vt_mode mode = { 0 };
 947
 948         vt = session_open_vt(s);
 949         if (vt < 0)
 950                 return;
 951
 952         (void) ioctl(vt, KDSETMODE, KD_TEXT);
 953
 954         if (read_one_line_file("/sys/module/vt/parameters/default_utf8", &utf8) >= 0 && *utf8 == '1')
 955                 kb = K_UNICODE;
 956
 957         (void) ioctl(vt, KDSKBMODE, kb);
 958
 959         mode.mode = VT_AUTO;
 960         (void) ioctl(vt, VT_SETMODE, &mode);
 961
 962         fchown(vt, 0, -1);
 963
 964         s->vtfd = safe_close(s->vtfd);
 965 }
 966
 967 void session_leave_vt(Session *s) {
 968         int r;
 969
 970         assert(s);
 971
 972         /* This is called whenever we get a VT-switch signal from the kernel.
 973          * We acknowledge all of them unconditionally. Note that session are
 974          * free to overwrite those handlers and we only register them for
 975          * sessions with controllers. Legacy sessions are not affected.
 976          * However, if we switch from a non-legacy to a legacy session, we must
 977          * make sure to pause all device before acknowledging the switch. We
 978          * process the real switch only after we are notified via sysfs, so the
 979          * legacy session might have already started using the devices. If we
 980          * don't pause the devices before the switch, we might confuse the
 981          * session we switch to. */
 982
 983         if (s->vtfd < 0)
 984                 return;
 985
 986         session_device_pause_all(s);
 987         r = ioctl(s->vtfd, VT_RELDISP, 1);
 988         if (r < 0)
 989                 log_debug_errno(errno, "Cannot release VT of session %s: %m", s->id);
 990 }
 991
 992 bool session_is_controller(Session *s, const char *sender) {
 993         assert(s);
 994
 995         return streq_ptr(s->controller, sender);
 996 }
 997
 998 static void session_release_controller(Session *s, bool notify) {
 999         _cleanup_free_ char *name = NULL;
1000         SessionDevice *sd;
1001
1002         if (!s->controller)
1003                 return;
1004
1005         name = s->controller;
1006
1007         /* By resetting the controller before releasing the devices, we won't
1008          * send notification signals. This avoids sending useless notifications
1009          * if the controller is released on disconnects. */
1010         if (!notify)
1011                 s->controller = NULL;
1012
1013         while ((sd = hashmap_first(s->devices)))
1014                 session_device_free(sd);
1015
1016         s->controller = NULL;
1017         manager_drop_busname(s->manager, name);
1018 }
1019
1020 int session_set_controller(Session *s, const char *sender, bool force) {
1021         _cleanup_free_ char *name = NULL;
1022         int r;
1023
1024         assert(s);
1025         assert(sender);
1026
1027         if (session_is_controller(s, sender))
1028                 return 0;
1029         if (s->controller && !force)
1030                 return -EBUSY;
1031
1032         name = strdup(sender);
1033         if (!name)
1034                 return -ENOMEM;
1035
1036         r = manager_watch_busname(s->manager, name);
1037         if (r)
1038                 return r;
1039
1040         /* When setting a session controller, we forcibly mute the VT and set
1041          * it into graphics-mode. Applications can override that by changing
1042          * VT state after calling TakeControl(). However, this serves as a good
1043          * default and well-behaving controllers can now ignore VTs entirely.
1044          * Note that we reset the VT on ReleaseControl() and if the controller
1045          * exits.
1046          * If logind crashes/restarts, we restore the controller during restart
1047          * or reset the VT in case it crashed/exited, too. */
1048         r = session_prepare_vt(s);
1049         if (r < 0) {
1050                 manager_drop_busname(s->manager, name);
1051                 return r;
1052         }
1053
1054         session_release_controller(s, true);
1055         s->controller = name;
1056         name = NULL;
1057         session_save(s);
1058
1059         return 0;
1060 }
1061
1062 void session_drop_controller(Session *s) {
1063         assert(s);
1064
1065         if (!s->controller)
1066                 return;
1067
1068         session_release_controller(s, false);
1069         session_save(s);
1070         session_restore_vt(s);
1071 }
1072
1073 static const char* const session_state_table[_SESSION_STATE_MAX] = {
1074         [SESSION_OPENING] = "opening",
1075         [SESSION_ONLINE] = "online",
1076         [SESSION_ACTIVE] = "active",
1077         [SESSION_CLOSING] = "closing"
1078 };
1079
1080 DEFINE_STRING_TABLE_LOOKUP(session_state, SessionState);
1081
1082 static const char* const session_type_table[_SESSION_TYPE_MAX] = {
1083         [SESSION_UNSPECIFIED] = "unspecified",
1084         [SESSION_TTY] = "tty",
1085         [SESSION_X11] = "x11",
1086         [SESSION_WAYLAND] = "wayland",
1087         [SESSION_MIR] = "mir",
1088         [SESSION_WEB] = "web",
1089 };
1090
1091 DEFINE_STRING_TABLE_LOOKUP(session_type, SessionType);
1092
1093 static const char* const session_class_table[_SESSION_CLASS_MAX] = {
1094         [SESSION_USER] = "user",
1095         [SESSION_GREETER] = "greeter",
1096         [SESSION_LOCK_SCREEN] = "lock-screen",
1097         [SESSION_BACKGROUND] = "background"
1098 };
1099
1100 DEFINE_STRING_TABLE_LOOKUP(session_class, SessionClass);
1101
1102 static const char* const kill_who_table[_KILL_WHO_MAX] = {
1103         [KILL_LEADER] = "leader",
1104         [KILL_ALL] = "all"
1105 };
1106
1107 DEFINE_STRING_TABLE_LOOKUP(kill_who, KillWho);