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 <string.h>
  24 #include <unistd.h>
  25 #include <fcntl.h>
  26
  27 #include "sd-id128.h"
  28 #include "sd-messages.h"
  29 #include "strv.h"
  30 #include "util.h"
  31 #include "mkdir.h"
  32 #include "path-util.h"
  33 #include "fileio.h"
  34 #include "audit.h"
  35 #include "bus-util.h"
  36 #include "bus-error.h"
  37 #include "logind-session.h"
  38
  39 static unsigned devt_hash_func(const void *p) {
  40         uint64_t u = *(const dev_t*)p;
  41
  42         return uint64_hash_func(&u);
  43 }
  44
  45 static int devt_compare_func(const void *_a, const void *_b) {
  46         dev_t a, b;
  47
  48         a = *(const dev_t*) _a;
  49         b = *(const dev_t*) _b;
  50
  51         return a < b ? -1 : (a > b ? 1 : 0);
  52 }
  53
  54 Session* session_new(Manager *m, const char *id) {
  55         Session *s;
  56
  57         assert(m);
  58         assert(id);
  59         assert(session_id_valid(id));
  60
  61         s = new0(Session, 1);
  62         if (!s)
  63                 return NULL;
  64
  65         s->state_file = strappend("/run/systemd/sessions/", id);
  66         if (!s->state_file) {
  67                 free(s);
  68                 return NULL;
  69         }
  70
  71         s->devices = hashmap_new(devt_hash_func, devt_compare_func);
  72         if (!s->devices) {
  73                 free(s->state_file);
  74                 free(s);
  75                 return NULL;
  76         }
  77
  78         s->id = path_get_file_name(s->state_file);
  79
  80         if (hashmap_put(m->sessions, s->id, s) < 0) {
  81                 hashmap_free(s->devices);
  82                 free(s->state_file);
  83                 free(s);
  84                 return NULL;
  85         }
  86
  87         s->manager = m;
  88         s->fifo_fd = -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         session_remove_fifo(s);
 102
 103         session_drop_controller(s);
 104
 105         while ((sd = hashmap_first(s->devices)))
 106                 session_device_free(sd);
 107
 108         hashmap_free(s->devices);
 109
 110         if (s->user) {
 111                 LIST_REMOVE(sessions_by_user, s->user->sessions, s);
 112
 113                 if (s->user->display == s)
 114                         s->user->display = NULL;
 115         }
 116
 117         if (s->seat) {
 118                 if (s->seat->active == s)
 119                         s->seat->active = NULL;
 120                 if (s->seat->pending_switch == s)
 121                         s->seat->pending_switch = NULL;
 122
 123                 LIST_REMOVE(sessions_by_seat, s->seat->sessions, s);
 124         }
 125
 126         if (s->scope) {
 127                 hashmap_remove(s->manager->session_units, s->scope);
 128                 free(s->scope);
 129         }
 130
 131         free(s->scope_job);
 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
 141         hashmap_remove(s->manager->sessions, s->id);
 142
 143         free(s->state_file);
 144         free(s);
 145 }
 146
 147 void session_set_user(Session *s, User *u) {
 148         assert(s);
 149         assert(!s->user);
 150
 151         s->user = u;
 152         LIST_PREPEND(sessions_by_user, u->sessions, s);
 153 }
 154
 155 int session_save(Session *s) {
 156         _cleanup_free_ char *temp_path = NULL;
 157         _cleanup_fclose_ FILE *f = NULL;
 158         int r = 0;
 159
 160         assert(s);
 161
 162         if (!s->user)
 163                 return -ESTALE;
 164
 165         if (!s->started)
 166                 return 0;
 167
 168         r = mkdir_safe_label("/run/systemd/sessions", 0755, 0, 0);
 169         if (r < 0)
 170                 goto finish;
 171
 172         r = fopen_temporary(s->state_file, &f, &temp_path);
 173         if (r < 0)
 174                 goto finish;
 175
 176         assert(s->user);
 177
 178         fchmod(fileno(f), 0644);
 179
 180         fprintf(f,
 181                 "# This is private data. Do not parse.\n"
 182                 "UID=%lu\n"
 183                 "USER=%s\n"
 184                 "ACTIVE=%i\n"
 185                 "STATE=%s\n"
 186                 "REMOTE=%i\n",
 187                 (unsigned long) s->user->uid,
 188                 s->user->name,
 189                 session_is_active(s),
 190                 session_state_to_string(session_get_state(s)),
 191                 s->remote);
 192
 193         if (s->type >= 0)
 194                 fprintf(f, "TYPE=%s\n", session_type_to_string(s->type));
 195
 196         if (s->class >= 0)
 197                 fprintf(f, "CLASS=%s\n", session_class_to_string(s->class));
 198
 199         if (s->scope)
 200                 fprintf(f, "SCOPE=%s\n", s->scope);
 201
 202         if (s->scope_job)
 203                 fprintf(f, "SCOPE_JOB=%s\n", s->scope_job);
 204
 205         if (s->fifo_path)
 206                 fprintf(f, "FIFO=%s\n", s->fifo_path);
 207
 208         if (s->seat)
 209                 fprintf(f, "SEAT=%s\n", s->seat->id);
 210
 211         if (s->tty)
 212                 fprintf(f, "TTY=%s\n", s->tty);
 213
 214         if (s->display)
 215                 fprintf(f, "DISPLAY=%s\n", s->display);
 216
 217         if (s->remote_host)
 218                 fprintf(f, "REMOTE_HOST=%s\n", s->remote_host);
 219
 220         if (s->remote_user)
 221                 fprintf(f, "REMOTE_USER=%s\n", s->remote_user);
 222
 223         if (s->service)
 224                 fprintf(f, "SERVICE=%s\n", s->service);
 225
 226         if (s->seat && seat_has_vts(s->seat))
 227                 fprintf(f, "VTNR=%i\n", s->vtnr);
 228
 229         if (s->leader > 0)
 230                 fprintf(f, "LEADER=%lu\n", (unsigned long) s->leader);
 231
 232         if (s->audit_id > 0)
 233                 fprintf(f, "AUDIT=%"PRIu32"\n", s->audit_id);
 234
 235         if (dual_timestamp_is_set(&s->timestamp))
 236                 fprintf(f,
 237                         "REALTIME=%llu\n"
 238                         "MONOTONIC=%llu\n",
 239                         (unsigned long long) s->timestamp.realtime,
 240                         (unsigned long long) s->timestamp.monotonic);
 241
 242         fflush(f);
 243
 244         if (ferror(f) || rename(temp_path, s->state_file) < 0) {
 245                 r = -errno;
 246                 unlink(s->state_file);
 247                 unlink(temp_path);
 248         }
 249
 250 finish:
 251         if (r < 0)
 252                 log_error("Failed to save session data for %s: %s", s->id, strerror(-r));
 253
 254         return r;
 255 }
 256
 257 int session_load(Session *s) {
 258         _cleanup_free_ char *remote = NULL,
 259                 *seat = NULL,
 260                 *vtnr = NULL,
 261                 *leader = NULL,
 262                 *type = NULL,
 263                 *class = NULL,
 264                 *uid = NULL,
 265                 *realtime = NULL,
 266                 *monotonic = NULL;
 267
 268         int k, r;
 269
 270         assert(s);
 271
 272         r = parse_env_file(s->state_file, NEWLINE,
 273                            "REMOTE",         &remote,
 274                            "SCOPE",          &s->scope,
 275                            "SCOPE_JOB",      &s->scope_job,
 276                            "FIFO",           &s->fifo_path,
 277                            "SEAT",           &seat,
 278                            "TTY",            &s->tty,
 279                            "DISPLAY",        &s->display,
 280                            "REMOTE_HOST",    &s->remote_host,
 281                            "REMOTE_USER",    &s->remote_user,
 282                            "SERVICE",        &s->service,
 283                            "VTNR",           &vtnr,
 284                            "LEADER",         &leader,
 285                            "TYPE",           &type,
 286                            "CLASS",          &class,
 287                            "UID",            &uid,
 288                            "REALTIME",       &realtime,
 289                            "MONOTONIC",      &monotonic,
 290                            NULL);
 291
 292         if (r < 0) {
 293                 log_error("Failed to read %s: %s", s->state_file, strerror(-r));
 294                 return r;
 295         }
 296
 297         if (!s->user) {
 298                 uid_t u;
 299                 User *user;
 300
 301                 if (!uid) {
 302                         log_error("UID not specified for session %s", s->id);
 303                         return -ENOENT;
 304                 }
 305
 306                 r = parse_uid(uid, &u);
 307                 if (r < 0)  {
 308                         log_error("Failed to parse UID value %s for session %s.", uid, s->id);
 309                         return r;
 310                 }
 311
 312                 user = hashmap_get(s->manager->users, ULONG_TO_PTR((unsigned long) u));
 313                 if (!user) {
 314                         log_error("User of session %s not known.", s->id);
 315                         return -ENOENT;
 316                 }
 317
 318                 session_set_user(s, user);
 319         }
 320
 321         if (remote) {
 322                 k = parse_boolean(remote);
 323                 if (k >= 0)
 324                         s->remote = k;
 325         }
 326
 327         if (seat && !s->seat) {
 328                 Seat *o;
 329
 330                 o = hashmap_get(s->manager->seats, seat);
 331                 if (o)
 332                         seat_attach_session(o, s);
 333         }
 334
 335         if (vtnr && s->seat && seat_has_vts(s->seat)) {
 336                 int v;
 337
 338                 k = safe_atoi(vtnr, &v);
 339                 if (k >= 0 && v >= 1)
 340                         s->vtnr = v;
 341         }
 342
 343         if (leader) {
 344                 k = parse_pid(leader, &s->leader);
 345                 if (k >= 0)
 346                         audit_session_from_pid(s->leader, &s->audit_id);
 347         }
 348
 349         if (type) {
 350                 SessionType t;
 351
 352                 t = session_type_from_string(type);
 353                 if (t >= 0)
 354                         s->type = t;
 355         }
 356
 357         if (class) {
 358                 SessionClass c;
 359
 360                 c = session_class_from_string(class);
 361                 if (c >= 0)
 362                         s->class = c;
 363         }
 364
 365         if (s->fifo_path) {
 366                 int fd;
 367
 368                 /* If we open an unopened pipe for reading we will not
 369                    get an EOF. to trigger an EOF we hence open it for
 370                    reading, but close it right-away which then will
 371                    trigger the EOF. */
 372
 373                 fd = session_create_fifo(s);
 374                 if (fd >= 0)
 375                         close_nointr_nofail(fd);
 376         }
 377
 378         if (realtime) {
 379                 unsigned long long l;
 380                 if (sscanf(realtime, "%llu", &l) > 0)
 381                         s->timestamp.realtime = l;
 382         }
 383
 384         if (monotonic) {
 385                 unsigned long long l;
 386                 if (sscanf(monotonic, "%llu", &l) > 0)
 387                         s->timestamp.monotonic = l;
 388         }
 389
 390         return r;
 391 }
 392
 393 int session_activate(Session *s) {
 394         unsigned int num_pending;
 395
 396         assert(s);
 397         assert(s->user);
 398
 399         if (!s->seat)
 400                 return -ENOTSUP;
 401
 402         if (s->seat->active == s)
 403                 return 0;
 404
 405         /* on seats with VTs, we let VTs manage session-switching */
 406         if (seat_has_vts(s->seat)) {
 407                 if (s->vtnr <= 0)
 408                         return -ENOTSUP;
 409
 410                 return chvt(s->vtnr);
 411         }
 412
 413         /* On seats without VTs, we implement session-switching in logind. We
 414          * try to pause all session-devices and wait until the session
 415          * controller acknowledged them. Once all devices are asleep, we simply
 416          * switch the active session and be done.
 417          * We save the session we want to switch to in seat->pending_switch and
 418          * seat_complete_switch() will perform the final switch. */
 419
 420         s->seat->pending_switch = s;
 421
 422         /* if no devices are running, immediately perform the session switch */
 423         num_pending = session_device_try_pause_all(s);
 424         if (!num_pending)
 425                 seat_complete_switch(s->seat);
 426
 427         return 0;
 428 }
 429
 430 static int session_link_x11_socket(Session *s) {
 431         _cleanup_free_ char *t = NULL, *f = NULL;
 432         char *c;
 433         size_t k;
 434
 435         assert(s);
 436         assert(s->user);
 437         assert(s->user->runtime_path);
 438
 439         if (s->user->display)
 440                 return 0;
 441
 442         if (!s->display || !display_is_local(s->display))
 443                 return 0;
 444
 445         k = strspn(s->display+1, "0123456789");
 446         f = new(char, sizeof("/tmp/.X11-unix/X") + k);
 447         if (!f)
 448                 return log_oom();
 449
 450         c = stpcpy(f, "/tmp/.X11-unix/X");
 451         memcpy(c, s->display+1, k);
 452         c[k] = 0;
 453
 454         if (access(f, F_OK) < 0) {
 455                 log_warning("Session %s has display %s with non-existing socket %s.", s->id, s->display, f);
 456                 return -ENOENT;
 457         }
 458
 459         /* Note that this cannot be in a subdir to avoid
 460          * vulnerabilities since we are privileged but the runtime
 461          * path is owned by the user */
 462
 463         t = strappend(s->user->runtime_path, "/X11-display");
 464         if (!t)
 465                 return log_oom();
 466
 467         if (link(f, t) < 0) {
 468                 if (errno == EEXIST) {
 469                         unlink(t);
 470
 471                         if (link(f, t) >= 0)
 472                                 goto done;
 473                 }
 474
 475                 if (symlink(f, t) < 0) {
 476
 477                         if (errno == EEXIST) {
 478                                 unlink(t);
 479
 480                                 if (symlink(f, t) >= 0)
 481                                         goto done;
 482                         }
 483
 484                         log_error("Failed to link %s to %s: %m", f, t);
 485                         return -errno;
 486                 }
 487         }
 488
 489 done:
 490         log_info("Linked %s to %s.", f, t);
 491         s->user->display = s;
 492
 493         return 0;
 494 }
 495
 496 static int session_start_scope(Session *s) {
 497         int r;
 498
 499         assert(s);
 500         assert(s->user);
 501         assert(s->user->slice);
 502
 503         if (!s->scope) {
 504                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 505                 _cleanup_free_ char *description = NULL;
 506                 const char *kill_mode;
 507                 char *scope, *job;
 508
 509                 description = strjoin("Session ", s->id, " of user ", s->user->name, NULL);
 510                 if (!description)
 511                         return log_oom();
 512
 513                 scope = strjoin("session-", s->id, ".scope", NULL);
 514                 if (!scope)
 515                         return log_oom();
 516
 517                 kill_mode = manager_shall_kill(s->manager, s->user->name) ? "control-group" : "none";
 518
 519                 r = manager_start_scope(s->manager, scope, s->leader, s->user->slice, description, "systemd-user-sessions.service", kill_mode, &error, &job);
 520                 if (r < 0) {
 521                         log_error("Failed to start session scope %s: %s %s",
 522                                   scope, bus_error_message(&error, r), error.name);
 523                         free(scope);
 524                         return r;
 525                 } else {
 526                         s->scope = scope;
 527
 528                         free(s->scope_job);
 529                         s->scope_job = job;
 530                 }
 531         }
 532
 533         if (s->scope)
 534                 hashmap_put(s->manager->session_units, s->scope, s);
 535
 536         return 0;
 537 }
 538
 539 int session_start(Session *s) {
 540         int r;
 541
 542         assert(s);
 543
 544         if (!s->user)
 545                 return -ESTALE;
 546
 547         if (s->started)
 548                 return 0;
 549
 550         r = user_start(s->user);
 551         if (r < 0)
 552                 return r;
 553
 554         /* Create cgroup */
 555         r = session_start_scope(s);
 556         if (r < 0)
 557                 return r;
 558
 559         log_struct(s->type == SESSION_TTY || s->type == SESSION_X11 ? LOG_INFO : LOG_DEBUG,
 560                    MESSAGE_ID(SD_MESSAGE_SESSION_START),
 561                    "SESSION_ID=%s", s->id,
 562                    "USER_ID=%s", s->user->name,
 563                    "LEADER=%lu", (unsigned long) s->leader,
 564                    "MESSAGE=New session %s of user %s.", s->id, s->user->name,
 565                    NULL);
 566
 567         /* Create X11 symlink */
 568         session_link_x11_socket(s);
 569
 570         if (!dual_timestamp_is_set(&s->timestamp))
 571                 dual_timestamp_get(&s->timestamp);
 572
 573         if (s->seat)
 574                 seat_read_active_vt(s->seat);
 575
 576         s->started = true;
 577
 578         /* Save session data */
 579         session_save(s);
 580         user_save(s->user);
 581
 582         session_send_signal(s, true);
 583
 584         if (s->seat) {
 585                 seat_save(s->seat);
 586
 587                 if (s->seat->active == s)
 588                         seat_send_changed(s->seat, "Sessions", "ActiveSession", NULL);
 589                 else
 590                         seat_send_changed(s->seat, "Sessions", NULL);
 591         }
 592
 593         user_send_changed(s->user, "Sessions", NULL);
 594
 595         return 0;
 596 }
 597
 598 static int session_stop_scope(Session *s) {
 599         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 600         char *job;
 601         int r;
 602
 603         assert(s);
 604
 605         if (!s->scope)
 606                 return 0;
 607
 608         r = manager_stop_unit(s->manager, s->scope, &error, &job);
 609         if (r < 0) {
 610                 log_error("Failed to stop session scope: %s", bus_error_message(&error, r));
 611                 return r;
 612         }
 613
 614         free(s->scope_job);
 615         s->scope_job = job;
 616
 617         return 0;
 618 }
 619
 620 static int session_unlink_x11_socket(Session *s) {
 621         _cleanup_free_ char *t = NULL;
 622         int r;
 623
 624         assert(s);
 625         assert(s->user);
 626
 627         if (s->user->display != s)
 628                 return 0;
 629
 630         s->user->display = NULL;
 631
 632         t = strappend(s->user->runtime_path, "/X11-display");
 633         if (!t)
 634                 return log_oom();
 635
 636         r = unlink(t);
 637         return r < 0 ? -errno : 0;
 638 }
 639
 640 int session_stop(Session *s) {
 641         int r;
 642
 643         assert(s);
 644
 645         if (!s->user)
 646                 return -ESTALE;
 647
 648         /* Kill cgroup */
 649         r = session_stop_scope(s);
 650
 651         session_save(s);
 652         user_save(s->user);
 653
 654         return r;
 655 }
 656
 657 int session_finalize(Session *s) {
 658         int r = 0;
 659         SessionDevice *sd;
 660
 661         assert(s);
 662
 663         if (!s->user)
 664                 return -ESTALE;
 665
 666         if (s->started)
 667                 log_struct(s->type == SESSION_TTY || s->type == SESSION_X11 ? LOG_INFO : LOG_DEBUG,
 668                            MESSAGE_ID(SD_MESSAGE_SESSION_STOP),
 669                            "SESSION_ID=%s", s->id,
 670                            "USER_ID=%s", s->user->name,
 671                            "LEADER=%lu", (unsigned long) s->leader,
 672                            "MESSAGE=Removed session %s.", s->id,
 673                            NULL);
 674
 675         /* Kill session devices */
 676         while ((sd = hashmap_first(s->devices)))
 677                 session_device_free(sd);
 678
 679         /* Remove X11 symlink */
 680         session_unlink_x11_socket(s);
 681
 682         unlink(s->state_file);
 683         session_add_to_gc_queue(s);
 684         user_add_to_gc_queue(s->user);
 685
 686         if (s->started) {
 687                 session_send_signal(s, false);
 688                 s->started = false;
 689         }
 690
 691         if (s->seat) {
 692                 if (s->seat->active == s)
 693                         seat_set_active(s->seat, NULL);
 694
 695                 seat_send_changed(s->seat, "Sessions", NULL);
 696                 seat_save(s->seat);
 697         }
 698
 699         user_send_changed(s->user, "Sessions", NULL);
 700         user_save(s->user);
 701
 702         return r;
 703 }
 704
 705 bool session_is_active(Session *s) {
 706         assert(s);
 707
 708         if (!s->seat)
 709                 return true;
 710
 711         return s->seat->active == s;
 712 }
 713
 714 static int get_tty_atime(const char *tty, usec_t *atime) {
 715         _cleanup_free_ char *p = NULL;
 716         struct stat st;
 717
 718         assert(tty);
 719         assert(atime);
 720
 721         if (!path_is_absolute(tty)) {
 722                 p = strappend("/dev/", tty);
 723                 if (!p)
 724                         return -ENOMEM;
 725
 726                 tty = p;
 727         } else if (!path_startswith(tty, "/dev/"))
 728                 return -ENOENT;
 729
 730         if (lstat(tty, &st) < 0)
 731                 return -errno;
 732
 733         *atime = timespec_load(&st.st_atim);
 734         return 0;
 735 }
 736
 737 static int get_process_ctty_atime(pid_t pid, usec_t *atime) {
 738         _cleanup_free_ char *p = NULL;
 739         int r;
 740
 741         assert(pid > 0);
 742         assert(atime);
 743
 744         r = get_ctty(pid, NULL, &p);
 745         if (r < 0)
 746                 return r;
 747
 748         return get_tty_atime(p, atime);
 749 }
 750
 751 int session_get_idle_hint(Session *s, dual_timestamp *t) {
 752         usec_t atime = 0, n;
 753         int r;
 754
 755         assert(s);
 756
 757         /* Explicit idle hint is set */
 758         if (s->idle_hint) {
 759                 if (t)
 760                         *t = s->idle_hint_timestamp;
 761
 762                 return s->idle_hint;
 763         }
 764
 765         /* Graphical sessions should really implement a real
 766          * idle hint logic */
 767         if (s->display)
 768                 goto dont_know;
 769
 770         /* For sessions with an explicitly configured tty, let's check
 771          * its atime */
 772         if (s->tty) {
 773                 r = get_tty_atime(s->tty, &atime);
 774                 if (r >= 0)
 775                         goto found_atime;
 776         }
 777
 778         /* For sessions with a leader but no explicitly configured
 779          * tty, let's check the controlling tty of the leader */
 780         if (s->leader > 0) {
 781                 r = get_process_ctty_atime(s->leader, &atime);
 782                 if (r >= 0)
 783                         goto found_atime;
 784         }
 785
 786 dont_know:
 787         if (t)
 788                 *t = s->idle_hint_timestamp;
 789
 790         return 0;
 791
 792 found_atime:
 793         if (t)
 794                 dual_timestamp_from_realtime(t, atime);
 795
 796         n = now(CLOCK_REALTIME);
 797
 798         if (s->manager->idle_action_usec <= 0)
 799                 return 0;
 800
 801         return atime + s->manager->idle_action_usec <= n;
 802 }
 803
 804 void session_set_idle_hint(Session *s, bool b) {
 805         assert(s);
 806
 807         if (s->idle_hint == b)
 808                 return;
 809
 810         s->idle_hint = b;
 811         dual_timestamp_get(&s->idle_hint_timestamp);
 812
 813         session_send_changed(s, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
 814
 815         if (s->seat)
 816                 seat_send_changed(s->seat, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
 817
 818         user_send_changed(s->user, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
 819         manager_send_changed(s->manager, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
 820 }
 821
 822 static int session_dispatch_fifo(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
 823         Session *s = userdata;
 824
 825         assert(s);
 826         assert(s->fifo_fd == fd);
 827
 828         /* EOF on the FIFO means the session died abnormally. */
 829
 830         session_remove_fifo(s);
 831         session_stop(s);
 832
 833         return 1;
 834 }
 835
 836 int session_create_fifo(Session *s) {
 837         int r;
 838
 839         assert(s);
 840
 841         /* Create FIFO */
 842         if (!s->fifo_path) {
 843                 r = mkdir_safe_label("/run/systemd/sessions", 0755, 0, 0);
 844                 if (r < 0)
 845                         return r;
 846
 847                 if (asprintf(&s->fifo_path, "/run/systemd/sessions/%s.ref", s->id) < 0)
 848                         return -ENOMEM;
 849
 850                 if (mkfifo(s->fifo_path, 0600) < 0 && errno != EEXIST)
 851                         return -errno;
 852         }
 853
 854         /* Open reading side */
 855         if (s->fifo_fd < 0) {
 856                 s->fifo_fd = open(s->fifo_path, O_RDONLY|O_CLOEXEC|O_NDELAY);
 857                 if (s->fifo_fd < 0)
 858                         return -errno;
 859
 860         }
 861
 862         if (!s->fifo_event_source) {
 863                 r = sd_event_add_io(s->manager->event, s->fifo_fd, 0, session_dispatch_fifo, s, &s->fifo_event_source);
 864                 if (r < 0)
 865                         return r;
 866
 867                 r = sd_event_source_set_priority(s->fifo_event_source, SD_EVENT_PRIORITY_IDLE);
 868                 if (r < 0)
 869                         return r;
 870         }
 871
 872         /* Open writing side */
 873         r = open(s->fifo_path, O_WRONLY|O_CLOEXEC|O_NDELAY);
 874         if (r < 0)
 875                 return -errno;
 876
 877         return r;
 878 }
 879
 880 void session_remove_fifo(Session *s) {
 881         assert(s);
 882
 883         if (s->fifo_event_source)
 884                 s->fifo_event_source = sd_event_source_unref(s->fifo_event_source);
 885
 886         if (s->fifo_fd >= 0) {
 887                 close_nointr_nofail(s->fifo_fd);
 888                 s->fifo_fd = -1;
 889         }
 890
 891         if (s->fifo_path) {
 892                 unlink(s->fifo_path);
 893                 free(s->fifo_path);
 894                 s->fifo_path = NULL;
 895         }
 896 }
 897
 898 bool session_check_gc(Session *s, bool drop_not_started) {
 899         int r;
 900
 901         assert(s);
 902
 903         if (drop_not_started && !s->started)
 904                 return false;
 905
 906         if (!s->user)
 907                 return false;
 908
 909         if (s->fifo_fd >= 0) {
 910                 r = pipe_eof(s->fifo_fd);
 911                 if (r < 0)
 912                         return true;
 913
 914                 if (r == 0)
 915                         return true;
 916         }
 917
 918         if (s->scope_job && manager_job_is_active(s->manager, s->scope_job))
 919                 return true;
 920
 921         if (s->scope && manager_unit_is_active(s->manager, s->scope))
 922                 return true;
 923
 924         return false;
 925 }
 926
 927 void session_add_to_gc_queue(Session *s) {
 928         assert(s);
 929
 930         if (s->in_gc_queue)
 931                 return;
 932
 933         LIST_PREPEND(gc_queue, s->manager->session_gc_queue, s);
 934         s->in_gc_queue = true;
 935 }
 936
 937 SessionState session_get_state(Session *s) {
 938         assert(s);
 939
 940         if (s->closing)
 941                 return SESSION_CLOSING;
 942
 943         if (s->scope_job)
 944                 return SESSION_OPENING;
 945
 946         if (s->fifo_fd < 0)
 947                 return SESSION_CLOSING;
 948
 949         if (session_is_active(s))
 950                 return SESSION_ACTIVE;
 951
 952         return SESSION_ONLINE;
 953 }
 954
 955 int session_kill(Session *s, KillWho who, int signo) {
 956         assert(s);
 957
 958         if (!s->scope)
 959                 return -ESRCH;
 960
 961         return manager_kill_unit(s->manager, s->scope, who, signo, NULL);
 962 }
 963
 964 bool session_is_controller(Session *s, const char *sender) {
 965         assert(s);
 966
 967         return streq_ptr(s->controller, sender);
 968 }
 969
 970 int session_set_controller(Session *s, const char *sender, bool force) {
 971         char *t;
 972         int r;
 973
 974         assert(s);
 975         assert(sender);
 976
 977         if (session_is_controller(s, sender))
 978                 return 0;
 979         if (s->controller && !force)
 980                 return -EBUSY;
 981
 982         t = strdup(sender);
 983         if (!t)
 984                 return -ENOMEM;
 985
 986         r = manager_watch_busname(s->manager, sender);
 987         if (r) {
 988                 free(t);
 989                 return r;
 990         }
 991
 992         session_drop_controller(s);
 993
 994         s->controller = t;
 995         return 0;
 996 }
 997
 998 void session_drop_controller(Session *s) {
 999         SessionDevice *sd;
1000
1001         assert(s);
1002
1003         if (!s->controller)
1004                 return;
1005
1006         manager_drop_busname(s->manager, s->controller);
1007         free(s->controller);
1008         s->controller = NULL;
1009
1010         /* Drop all devices as they're now unused. Do that after the controller
1011          * is released to avoid sending out useles dbus signals. */
1012         while ((sd = hashmap_first(s->devices)))
1013                 session_device_free(sd);
1014 }
1015
1016 static const char* const session_state_table[_SESSION_STATE_MAX] = {
1017         [SESSION_OPENING] = "opening",
1018         [SESSION_ONLINE] = "online",
1019         [SESSION_ACTIVE] = "active",
1020         [SESSION_CLOSING] = "closing"
1021 };
1022
1023 DEFINE_STRING_TABLE_LOOKUP(session_state, SessionState);
1024
1025 static const char* const session_type_table[_SESSION_TYPE_MAX] = {
1026         [SESSION_TTY] = "tty",
1027         [SESSION_X11] = "x11",
1028         [SESSION_UNSPECIFIED] = "unspecified"
1029 };
1030
1031 DEFINE_STRING_TABLE_LOOKUP(session_type, SessionType);
1032
1033 static const char* const session_class_table[_SESSION_CLASS_MAX] = {
1034         [SESSION_USER] = "user",
1035         [SESSION_GREETER] = "greeter",
1036         [SESSION_LOCK_SCREEN] = "lock-screen",
1037         [SESSION_BACKGROUND] = "background"
1038 };
1039
1040 DEFINE_STRING_TABLE_LOOKUP(session_class, SessionClass);
1041
1042 static const char* const kill_who_table[_KILL_WHO_MAX] = {
1043         [KILL_LEADER] = "leader",
1044         [KILL_ALL] = "all"
1045 };
1046
1047 DEFINE_STRING_TABLE_LOOKUP(kill_who, KillWho);