src/login/logind.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2011 Lennart Poettering
   6 ***/
   7
   8 #include <errno.h>
   9 #include <fcntl.h>
  10 #include <string.h>
  11 #include <unistd.h>
  12
  13 #if 0 /// elogind needs the systems udev header
  14 #include "libudev.h"
  15 #else
  16 #include <libudev.h>
  17 #endif // 0
  18 #include "sd-daemon.h"
  19
  20 #include "alloc-util.h"
  21 #include "bus-error.h"
  22 #include "bus-util.h"
  23 //#include "cgroup-util.h"
  24 #include "def.h"
  25 #include "dirent-util.h"
  26 #include "fd-util.h"
  27 #include "format-util.h"
  28 #include "fs-util.h"
  29 #include "logind.h"
  30 //#include "parse-util.h"
  31 //#include "process-util.h"
  32 #include "selinux-util.h"
  33 #include "signal-util.h"
  34 #include "strv.h"
  35 #include "udev-util.h"
  36 /// Additional includes needed by elogind
  37 #include "cgroup.h"       // From src/core/
  38 #include "elogind.h"
  39 #include "label.h"
  40 #include "musl_missing.h"
  41 #include "process-util.h"
  42 #include "cgroup-util.h"
  43
  44 static Manager* manager_unref(Manager *m);
  45 DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_unref);
  46
  47 #if 0 /// elogind does not support autospawning of vts
  48 #endif // 0
  49 static int manager_new(Manager **ret) {
  50         _cleanup_(manager_unrefp) Manager *m = NULL;
  51         int r;
  52
  53         assert(ret);
  54
  55         m = new0(Manager, 1);
  56         if (!m)
  57                 return -ENOMEM;
  58
  59         m->console_active_fd = -1;
  60 #if 0 /// UNNEEDED by elogind
  61         m->reserve_vt_fd = -1;
  62 #endif // 0
  63
  64         m->idle_action_not_before_usec = now(CLOCK_MONOTONIC);
  65
  66         m->devices = hashmap_new(&string_hash_ops);
  67         m->seats = hashmap_new(&string_hash_ops);
  68         m->sessions = hashmap_new(&string_hash_ops);
  69         m->users = hashmap_new(NULL);
  70         m->inhibitors = hashmap_new(&string_hash_ops);
  71         m->buttons = hashmap_new(&string_hash_ops);
  72
  73         m->user_units = hashmap_new(&string_hash_ops);
  74         m->session_units = hashmap_new(&string_hash_ops);
  75
  76         if (!m->devices || !m->seats || !m->sessions || !m->users || !m->inhibitors || !m->buttons || !m->user_units || !m->session_units)
  77                 return -ENOMEM;
  78
  79 #if 1 /// elogind needs some more data
  80         r = elogind_manager_new(m);
  81         if (r < 0)
  82                 goto fail;
  83 #endif // 1
  84         m->udev = udev_new();
  85         if (!m->udev)
  86                 return -errno;
  87
  88         r = sd_event_default(&m->event);
  89         if (r < 0)
  90                 return r;
  91
  92         (void) sd_event_set_watchdog(m->event, true);
  93
  94         manager_reset_config(m);
  95
  96         *ret = TAKE_PTR(m);
  97         return 0;
  98 }
  99
 100 static Manager* manager_unref(Manager *m) {
 101         Session *session;
 102         User *u;
 103         Device *d;
 104         Seat *s;
 105         Inhibitor *i;
 106         Button *b;
 107
 108         if (!m)
 109                 return NULL;
 110
 111         while ((session = hashmap_first(m->sessions)))
 112                 session_free(session);
 113
 114         while ((u = hashmap_first(m->users)))
 115                 user_free(u);
 116
 117         while ((d = hashmap_first(m->devices)))
 118                 device_free(d);
 119
 120         while ((s = hashmap_first(m->seats)))
 121                 seat_free(s);
 122
 123         while ((i = hashmap_first(m->inhibitors)))
 124                 inhibitor_free(i);
 125
 126         while ((b = hashmap_first(m->buttons)))
 127                 button_free(b);
 128
 129         hashmap_free(m->devices);
 130         hashmap_free(m->seats);
 131         hashmap_free(m->sessions);
 132         hashmap_free(m->users);
 133         hashmap_free(m->inhibitors);
 134         hashmap_free(m->buttons);
 135
 136         hashmap_free(m->user_units);
 137         hashmap_free(m->session_units);
 138
 139         sd_event_source_unref(m->idle_action_event_source);
 140         sd_event_source_unref(m->inhibit_timeout_source);
 141         sd_event_source_unref(m->scheduled_shutdown_timeout_source);
 142         sd_event_source_unref(m->nologin_timeout_source);
 143         sd_event_source_unref(m->wall_message_timeout_source);
 144
 145         sd_event_source_unref(m->console_active_event_source);
 146         sd_event_source_unref(m->udev_seat_event_source);
 147         sd_event_source_unref(m->udev_device_event_source);
 148         sd_event_source_unref(m->udev_vcsa_event_source);
 149         sd_event_source_unref(m->udev_button_event_source);
 150         sd_event_source_unref(m->lid_switch_ignore_event_source);
 151
 152         safe_close(m->console_active_fd);
 153
 154         udev_monitor_unref(m->udev_seat_monitor);
 155         udev_monitor_unref(m->udev_device_monitor);
 156         udev_monitor_unref(m->udev_vcsa_monitor);
 157         udev_monitor_unref(m->udev_button_monitor);
 158
 159         udev_unref(m->udev);
 160
 161         if (m->unlink_nologin)
 162                 (void) unlink_or_warn("/run/nologin");
 163
 164         bus_verify_polkit_async_registry_free(m->polkit_registry);
 165
 166         sd_bus_unref(m->bus);
 167         sd_event_unref(m->event);
 168
 169 #if 0 /// elogind does not support autospawning of vts
 170         safe_close(m->reserve_vt_fd);
 171 #endif // 0
 172 #if 1 /// elogind has to free its own data
 173         elogind_manager_free(m);
 174 #endif // 1
 175
 176         strv_free(m->kill_only_users);
 177         strv_free(m->kill_exclude_users);
 178
 179         free(m->scheduled_shutdown_type);
 180         free(m->scheduled_shutdown_tty);
 181         free(m->wall_message);
 182 #if 0 /// UNNEEDED by elogind
 183         free(m->action_job);
 184 #endif // 0
 185
 186         return mfree(m);
 187 }
 188
 189 static int manager_enumerate_devices(Manager *m) {
 190         struct udev_list_entry *item = NULL, *first = NULL;
 191         _cleanup_(udev_enumerate_unrefp) struct udev_enumerate *e = NULL;
 192         int r;
 193
 194         assert(m);
 195
 196         /* Loads devices from udev and creates seats for them as
 197          * necessary */
 198
 199         e = udev_enumerate_new(m->udev);
 200         if (!e)
 201                 return -ENOMEM;
 202
 203         r = udev_enumerate_add_match_tag(e, "master-of-seat");
 204         if (r < 0)
 205                 return r;
 206
 207         r = udev_enumerate_add_match_is_initialized(e);
 208         if (r < 0)
 209                 return r;
 210
 211         r = udev_enumerate_scan_devices(e);
 212         if (r < 0)
 213                 return r;
 214
 215         first = udev_enumerate_get_list_entry(e);
 216         udev_list_entry_foreach(item, first) {
 217                 _cleanup_(udev_device_unrefp) struct udev_device *d = NULL;
 218                 int k;
 219
 220                 d = udev_device_new_from_syspath(m->udev, udev_list_entry_get_name(item));
 221                 if (!d)
 222                         return -ENOMEM;
 223
 224                 k = manager_process_seat_device(m, d);
 225                 if (k < 0)
 226                         r = k;
 227         }
 228
 229         return r;
 230 }
 231
 232 static int manager_enumerate_buttons(Manager *m) {
 233         _cleanup_(udev_enumerate_unrefp) struct udev_enumerate *e = NULL;
 234         struct udev_list_entry *item = NULL, *first = NULL;
 235         int r;
 236
 237         assert(m);
 238
 239         /* Loads buttons from udev */
 240
 241         if (manager_all_buttons_ignored(m))
 242                 return 0;
 243
 244         e = udev_enumerate_new(m->udev);
 245         if (!e)
 246                 return -ENOMEM;
 247
 248         r = udev_enumerate_add_match_subsystem(e, "input");
 249         if (r < 0)
 250                 return r;
 251
 252         r = udev_enumerate_add_match_tag(e, "power-switch");
 253         if (r < 0)
 254                 return r;
 255
 256         r = udev_enumerate_add_match_is_initialized(e);
 257         if (r < 0)
 258                 return r;
 259
 260         r = udev_enumerate_scan_devices(e);
 261         if (r < 0)
 262                 return r;
 263
 264         first = udev_enumerate_get_list_entry(e);
 265         udev_list_entry_foreach(item, first) {
 266                 _cleanup_(udev_device_unrefp) struct udev_device *d = NULL;
 267                 int k;
 268
 269                 d = udev_device_new_from_syspath(m->udev, udev_list_entry_get_name(item));
 270                 if (!d)
 271                         return -ENOMEM;
 272
 273                 k = manager_process_button_device(m, d);
 274                 if (k < 0)
 275                         r = k;
 276         }
 277
 278         return r;
 279 }
 280
 281 static int manager_enumerate_seats(Manager *m) {
 282         _cleanup_closedir_ DIR *d = NULL;
 283         struct dirent *de;
 284         int r = 0;
 285
 286         assert(m);
 287
 288         /* This loads data about seats stored on disk, but does not
 289          * actually create any seats. Removes data of seats that no
 290          * longer exist. */
 291
 292         d = opendir("/run/systemd/seats");
 293         if (!d) {
 294                 if (errno == ENOENT)
 295                         return 0;
 296
 297                 return log_error_errno(errno, "Failed to open /run/systemd/seats: %m");
 298         }
 299
 300         FOREACH_DIRENT(de, d, return -errno) {
 301                 Seat *s;
 302                 int k;
 303
 304                 if (!dirent_is_file(de))
 305                         continue;
 306
 307                 s = hashmap_get(m->seats, de->d_name);
 308                 if (!s) {
 309                         if (unlinkat(dirfd(d), de->d_name, 0) < 0)
 310                                 log_warning("Failed to remove /run/systemd/seats/%s: %m",
 311                                             de->d_name);
 312                         continue;
 313                 }
 314
 315                 k = seat_load(s);
 316                 if (k < 0)
 317                         r = k;
 318         }
 319
 320         return r;
 321 }
 322
 323 static int manager_enumerate_linger_users(Manager *m) {
 324         _cleanup_closedir_ DIR *d = NULL;
 325         struct dirent *de;
 326         int r = 0;
 327
 328         assert(m);
 329
 330         d = opendir("/var/lib/elogind/linger");
 331         if (!d) {
 332                 if (errno == ENOENT)
 333                         return 0;
 334
 335                 return log_error_errno(errno, "Failed to open /var/lib/elogind/linger/: %m");
 336         }
 337
 338         FOREACH_DIRENT(de, d, return -errno) {
 339                 int k;
 340
 341                 if (!dirent_is_file(de))
 342                         continue;
 343
 344                 k = manager_add_user_by_name(m, de->d_name, NULL);
 345                 if (k < 0) {
 346                         log_notice_errno(k, "Couldn't add lingering user %s: %m", de->d_name);
 347                         r = k;
 348                 }
 349         }
 350
 351         return r;
 352 }
 353
 354 static int manager_enumerate_users(Manager *m) {
 355         _cleanup_closedir_ DIR *d = NULL;
 356         struct dirent *de;
 357         int r, k;
 358
 359         assert(m);
 360
 361         /* Add lingering users */
 362         r = manager_enumerate_linger_users(m);
 363
 364         /* Read in user data stored on disk */
 365         d = opendir("/run/systemd/users");
 366         if (!d) {
 367                 if (errno == ENOENT)
 368                         return 0;
 369
 370                 return log_error_errno(errno, "Failed to open /run/systemd/users: %m");
 371         }
 372
 373         FOREACH_DIRENT(de, d, return -errno) {
 374                 User *u;
 375
 376                 if (!dirent_is_file(de))
 377                         continue;
 378
 379                 k = manager_add_user_by_name(m, de->d_name, &u);
 380                 if (k < 0) {
 381                         log_error_errno(k, "Failed to add user by file name %s: %m", de->d_name);
 382
 383                         r = k;
 384                         continue;
 385                 }
 386
 387                 user_add_to_gc_queue(u);
 388
 389                 k = user_load(u);
 390                 if (k < 0)
 391                         r = k;
 392         }
 393
 394         return r;
 395 }
 396
 397 static int parse_fdname(const char *fdname, char **session_id, dev_t *dev) {
 398         _cleanup_strv_free_ char **parts = NULL;
 399         _cleanup_free_ char *id = NULL;
 400         unsigned int major, minor;
 401         int r;
 402
 403         parts = strv_split(fdname, "-");
 404         if (!parts)
 405                 return -ENOMEM;
 406         if (strv_length(parts) != 5)
 407                 return -EINVAL;
 408
 409         if (!streq(parts[0], "session"))
 410                 return -EINVAL;
 411         id = strdup(parts[1]);
 412         if (!id)
 413                 return -ENOMEM;
 414
 415         if (!streq(parts[2], "device"))
 416                 return -EINVAL;
 417         r = safe_atou(parts[3], &major) ||
 418             safe_atou(parts[4], &minor);
 419         if (r < 0)
 420                 return r;
 421
 422         *dev = makedev(major, minor);
 423         *session_id = TAKE_PTR(id);
 424
 425         return 0;
 426 }
 427
 428 static int manager_attach_fds(Manager *m) {
 429         _cleanup_strv_free_ char **fdnames = NULL;
 430         int n, i, fd;
 431
 432         /* Upon restart, PID1 will send us back all fds of session devices
 433          * that we previously opened. Each file descriptor is associated
 434          * with a given session. The session ids are passed through FDNAMES. */
 435
 436         n = sd_listen_fds_with_names(true, &fdnames);
 437         if (n <= 0)
 438                 return n;
 439
 440         for (i = 0; i < n; i++) {
 441                 _cleanup_free_ char *id = NULL;
 442                 dev_t dev;
 443                 struct stat st;
 444                 SessionDevice *sd;
 445                 Session *s;
 446                 int r;
 447
 448                 fd = SD_LISTEN_FDS_START + i;
 449
 450                 r = parse_fdname(fdnames[i], &id, &dev);
 451                 if (r < 0) {
 452                         log_debug_errno(r, "Failed to parse fd name %s: %m", fdnames[i]);
 453                         close_nointr(fd);
 454                         continue;
 455                 }
 456
 457                 s = hashmap_get(m->sessions, id);
 458                 if (!s) {
 459                         /* If the session doesn't exist anymore, the associated session
 460                          * device attached to this fd doesn't either. Let's simply close
 461                          * this fd. */
 462                         log_debug("Failed to attach fd for unknown session: %s", id);
 463                         close_nointr(fd);
 464                         continue;
 465                 }
 466
 467                 if (fstat(fd, &st) < 0) {
 468                         /* The device is allowed to go away at a random point, in which
 469                          * case fstat failing is expected. */
 470                         log_debug_errno(errno, "Failed to stat device fd for session %s: %m", id);
 471                         close_nointr(fd);
 472                         continue;
 473                 }
 474
 475                 if (!S_ISCHR(st.st_mode) || st.st_rdev != dev) {
 476                         log_debug("Device fd doesn't point to the expected character device node");
 477                         close_nointr(fd);
 478                         continue;
 479                 }
 480
 481                 sd = hashmap_get(s->devices, &dev);
 482                 if (!sd) {
 483                         /* Weird, we got an fd for a session device which wasn't
 484                          * recorded in the session state file... */
 485                         log_warning("Got fd for missing session device [%u:%u] in session %s",
 486                                     major(dev), minor(dev), s->id);
 487                         close_nointr(fd);
 488                         continue;
 489                 }
 490
 491                 log_debug("Attaching fd to session device [%u:%u] for session %s",
 492                           major(dev), minor(dev), s->id);
 493
 494                 session_device_attach_fd(sd, fd, s->was_active);
 495         }
 496
 497         return 0;
 498 }
 499
 500 static int manager_enumerate_sessions(Manager *m) {
 501         _cleanup_closedir_ DIR *d = NULL;
 502         struct dirent *de;
 503         int r = 0, k;
 504
 505         assert(m);
 506
 507         /* Read in session data stored on disk */
 508         d = opendir("/run/systemd/sessions");
 509         if (!d) {
 510                 if (errno == ENOENT)
 511                         return 0;
 512
 513                 return log_error_errno(errno, "Failed to open /run/systemd/sessions: %m");
 514         }
 515
 516         FOREACH_DIRENT(de, d, return -errno) {
 517                 struct Session *s;
 518
 519                 if (!dirent_is_file(de))
 520                         continue;
 521
 522                 if (!session_id_valid(de->d_name)) {
 523                         log_warning("Invalid session file name '%s', ignoring.", de->d_name);
 524                         r = -EINVAL;
 525                         continue;
 526                 }
 527
 528                 k = manager_add_session(m, de->d_name, &s);
 529                 if (k < 0) {
 530                         log_error_errno(k, "Failed to add session by file name %s: %m", de->d_name);
 531                         r = k;
 532                         continue;
 533                 }
 534
 535                 session_add_to_gc_queue(s);
 536
 537                 k = session_load(s);
 538                 if (k < 0)
 539                         r = k;
 540         }
 541
 542         /* We might be restarted and PID1 could have sent us back the
 543          * session device fds we previously saved. */
 544         k = manager_attach_fds(m);
 545         if (k < 0)
 546                 log_warning_errno(k, "Failed to reattach session device fds: %m");
 547
 548         return r;
 549 }
 550
 551 static int manager_enumerate_inhibitors(Manager *m) {
 552         _cleanup_closedir_ DIR *d = NULL;
 553         struct dirent *de;
 554         int r = 0;
 555
 556         assert(m);
 557
 558         d = opendir("/run/systemd/inhibit");
 559         if (!d) {
 560                 if (errno == ENOENT)
 561                         return 0;
 562
 563                 return log_error_errno(errno, "Failed to open /run/systemd/inhibit: %m");
 564         }
 565
 566         FOREACH_DIRENT(de, d, return -errno) {
 567                 int k;
 568                 Inhibitor *i;
 569
 570                 if (!dirent_is_file(de))
 571                         continue;
 572
 573                 k = manager_add_inhibitor(m, de->d_name, &i);
 574                 if (k < 0) {
 575                         log_notice_errno(k, "Couldn't add inhibitor %s: %m", de->d_name);
 576                         r = k;
 577                         continue;
 578                 }
 579
 580                 k = inhibitor_load(i);
 581                 if (k < 0)
 582                         r = k;
 583         }
 584
 585         return r;
 586 }
 587
 588 static int manager_dispatch_seat_udev(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 589         _cleanup_(udev_device_unrefp) struct udev_device *d = NULL;
 590         Manager *m = userdata;
 591
 592         assert(m);
 593
 594         d = udev_monitor_receive_device(m->udev_seat_monitor);
 595         if (!d)
 596                 return -ENOMEM;
 597
 598         manager_process_seat_device(m, d);
 599         return 0;
 600 }
 601
 602 static int manager_dispatch_device_udev(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 603         _cleanup_(udev_device_unrefp) struct udev_device *d = NULL;
 604         Manager *m = userdata;
 605
 606         assert(m);
 607
 608         d = udev_monitor_receive_device(m->udev_device_monitor);
 609         if (!d)
 610                 return -ENOMEM;
 611
 612         manager_process_seat_device(m, d);
 613         return 0;
 614 }
 615
 616 #if 0 /// UNNEEDED by elogind
 617 static int manager_dispatch_vcsa_udev(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 618         _cleanup_(udev_device_unrefp) struct udev_device *d = NULL;
 619         Manager *m = userdata;
 620         const char *name;
 621
 622         assert(m);
 623
 624         d = udev_monitor_receive_device(m->udev_vcsa_monitor);
 625         if (!d)
 626                 return -ENOMEM;
 627
 628         name = udev_device_get_sysname(d);
 629
 630         /* Whenever a VCSA device is removed try to reallocate our
 631          * VTs, to make sure our auto VTs never go away. */
 632
 633         if (name && startswith(name, "vcsa") && streq_ptr(udev_device_get_action(d), "remove"))
 634                 seat_preallocate_vts(m->seat0);
 635
 636         return 0;
 637 }
 638 #endif // 0
 639
 640 static int manager_dispatch_button_udev(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 641         _cleanup_(udev_device_unrefp) struct udev_device *d = NULL;
 642         Manager *m = userdata;
 643
 644         assert(m);
 645
 646         d = udev_monitor_receive_device(m->udev_button_monitor);
 647         if (!d)
 648                 return -ENOMEM;
 649
 650         manager_process_button_device(m, d);
 651         return 0;
 652 }
 653
 654 static int manager_dispatch_console(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 655         Manager *m = userdata;
 656
 657         assert(m);
 658         assert(m->seat0);
 659         assert(m->console_active_fd == fd);
 660
 661         seat_read_active_vt(m->seat0);
 662         return 0;
 663 }
 664
 665 #if 0 /// UNNEEDED by elogind
 666 static int manager_reserve_vt(Manager *m) {
 667         _cleanup_free_ char *p = NULL;
 668
 669         assert(m);
 670
 671         if (m->reserve_vt <= 0)
 672                 return 0;
 673
 674         if (asprintf(&p, "/dev/tty%u", m->reserve_vt) < 0)
 675                 return log_oom();
 676
 677         m->reserve_vt_fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC|O_NONBLOCK);
 678         if (m->reserve_vt_fd < 0) {
 679
 680                 /* Don't complain on VT-less systems */
 681                 if (errno != ENOENT)
 682                         log_warning_errno(errno, "Failed to pin reserved VT: %m");
 683                 return -errno;
 684         }
 685
 686         return 0;
 687 }
 688 #endif // 0
 689
 690 static int manager_connect_bus(Manager *m) {
 691         int r;
 692
 693         assert(m);
 694         assert(!m->bus);
 695
 696         r = sd_bus_default_system(&m->bus);
 697         if (r < 0)
 698                 return log_error_errno(r, "Failed to connect to system bus: %m");
 699
 700         r = sd_bus_add_object_vtable(m->bus, NULL, "/org/freedesktop/login1", "org.freedesktop.login1.Manager", manager_vtable, m);
 701         if (r < 0)
 702                 return log_error_errno(r, "Failed to add manager object vtable: %m");
 703
 704         r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/login1/seat", "org.freedesktop.login1.Seat", seat_vtable, seat_object_find, m);
 705         if (r < 0)
 706                 return log_error_errno(r, "Failed to add seat object vtable: %m");
 707
 708         r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/login1/seat", seat_node_enumerator, m);
 709         if (r < 0)
 710                 return log_error_errno(r, "Failed to add seat enumerator: %m");
 711
 712         r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/login1/session", "org.freedesktop.login1.Session", session_vtable, session_object_find, m);
 713         if (r < 0)
 714                 return log_error_errno(r, "Failed to add session object vtable: %m");
 715
 716         r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/login1/session", session_node_enumerator, m);
 717         if (r < 0)
 718                 return log_error_errno(r, "Failed to add session enumerator: %m");
 719
 720         r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/login1/user", "org.freedesktop.login1.User", user_vtable, user_object_find, m);
 721         if (r < 0)
 722                 return log_error_errno(r, "Failed to add user object vtable: %m");
 723
 724         r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/login1/user", user_node_enumerator, m);
 725         if (r < 0)
 726                 return log_error_errno(r, "Failed to add user enumerator: %m");
 727
 728 #if 0 /// elogind does not support systemd as PID 1
 729         r = sd_bus_match_signal_async(
 730                         m->bus,
 731                         NULL,
 732                         "org.freedesktop.systemd1",
 733                         "/org/freedesktop/systemd1",
 734                         "org.freedesktop.systemd1.Manager",
 735                         "JobRemoved",
 736                         match_job_removed, NULL, m);
 737         if (r < 0)
 738                 return log_error_errno(r, "Failed to request match for JobRemoved: %m");
 739
 740         r = sd_bus_match_signal_async(
 741                         m->bus,
 742                         NULL,
 743                         "org.freedesktop.systemd1",
 744                         "/org/freedesktop/systemd1",
 745                         "org.freedesktop.systemd1.Manager",
 746                         "UnitRemoved",
 747                         match_unit_removed, NULL, m);
 748         if (r < 0)
 749                 return log_error_errno(r, "Failed to request match for UnitRemoved: %m");
 750
 751         r = sd_bus_match_signal_async(
 752                         m->bus,
 753                         NULL,
 754                         "org.freedesktop.systemd1",
 755                         NULL,
 756                         "org.freedesktop.DBus.Properties",
 757                         "PropertiesChanged",
 758                         match_properties_changed, NULL, m);
 759         if (r < 0)
 760                 return log_error_errno(r, "Failed to request match for PropertiesChanged: %m");
 761
 762         r = sd_bus_match_signal_async(
 763                         m->bus,
 764                         NULL,
 765                         "org.freedesktop.systemd1",
 766                         "/org/freedesktop/systemd1",
 767                         "org.freedesktop.systemd1.Manager",
 768                         "Reloading",
 769                         match_reloading, NULL, m);
 770         if (r < 0)
 771                 return log_error_errno(r, "Failed to request match for Reloading: %m");
 772
 773         r = sd_bus_call_method_async(
 774                         m->bus,
 775                         NULL,
 776                         "org.freedesktop.systemd1",
 777                         "/org/freedesktop/systemd1",
 778                         "org.freedesktop.systemd1.Manager",
 779                         "Subscribe",
 780                         NULL, NULL,
 781                         NULL);
 782 #endif // 0
 783         if (r < 0)
 784                 return log_error_errno(r, "Failed to enable subscription: %m");
 785
 786         r = sd_bus_request_name_async(m->bus, NULL, "org.freedesktop.login1", 0, NULL, NULL);
 787         if (r < 0)
 788                 return log_error_errno(r, "Failed to request name: %m");
 789
 790         r = sd_bus_attach_event(m->bus, m->event, SD_EVENT_PRIORITY_NORMAL);
 791         if (r < 0)
 792                 return log_error_errno(r, "Failed to attach bus to event loop: %m");
 793
 794 #if 0 /// elogind has to setup its release agent
 795         return 0;
 796 #else
 797         r = elogind_setup_cgroups_agent(m);
 798
 799         return r;
 800 #endif // 0
 801 }
 802
 803 static int manager_vt_switch(sd_event_source *src, const struct signalfd_siginfo *si, void *data) {
 804         Manager *m = data;
 805         Session *active, *iter;
 806
 807         /*
 808          * We got a VT-switch signal and we have to acknowledge it immediately.
 809          * Preferably, we'd just use m->seat0->active->vtfd, but unfortunately,
 810          * old user-space might run multiple sessions on a single VT, *sigh*.
 811          * Therefore, we have to iterate all sessions and find one with a vtfd
 812          * on the requested VT.
 813          * As only VTs with active controllers have VT_PROCESS set, our current
 814          * notion of the active VT might be wrong (for instance if the switch
 815          * happens while we setup VT_PROCESS). Therefore, read the current VT
 816          * first and then use s->active->vtnr as reference. Note that this is
 817          * not racy, as no further VT-switch can happen as long as we're in
 818          * synchronous VT_PROCESS mode.
 819          */
 820
 821         assert(m->seat0);
 822         seat_read_active_vt(m->seat0);
 823
 824         active = m->seat0->active;
 825         if (!active || active->vtnr < 1) {
 826                 log_warning("Received VT_PROCESS signal without a registered session on that VT.");
 827                 return 0;
 828         }
 829
 830         if (active->vtfd >= 0) {
 831                 session_leave_vt(active);
 832         } else {
 833                 LIST_FOREACH(sessions_by_seat, iter, m->seat0->sessions) {
 834                         if (iter->vtnr == active->vtnr && iter->vtfd >= 0) {
 835                                 session_leave_vt(iter);
 836                                 break;
 837                         }
 838                 }
 839         }
 840
 841         return 0;
 842 }
 843
 844 static int manager_connect_console(Manager *m) {
 845         int r;
 846
 847         assert(m);
 848         assert(m->console_active_fd < 0);
 849
 850         /* On certain architectures (S390 and Xen, and containers),
 851            /dev/tty0 does not exist, so don't fail if we can't open
 852            it. */
 853         if (access("/dev/tty0", F_OK) < 0)
 854                 return 0;
 855
 856         m->console_active_fd = open("/sys/class/tty/tty0/active", O_RDONLY|O_NOCTTY|O_CLOEXEC);
 857         if (m->console_active_fd < 0) {
 858
 859                 /* On some systems the device node /dev/tty0 may exist
 860                  * even though /sys/class/tty/tty0 does not. */
 861                 if (errno == ENOENT)
 862                         return 0;
 863
 864                 return log_error_errno(errno, "Failed to open /sys/class/tty/tty0/active: %m");
 865         }
 866
 867         r = sd_event_add_io(m->event, &m->console_active_event_source, m->console_active_fd, 0, manager_dispatch_console, m);
 868         if (r < 0) {
 869                 log_error("Failed to watch foreground console");
 870                 return r;
 871         }
 872
 873         /*
 874          * SIGRTMIN is used as global VT-release signal, SIGRTMIN + 1 is used
 875          * as VT-acquire signal. We ignore any acquire-events (yes, we still
 876          * have to provide a valid signal-number for it!) and acknowledge all
 877          * release events immediately.
 878          */
 879
 880         if (SIGRTMIN + 1 > SIGRTMAX) {
 881                 log_error("Not enough real-time signals available: %u-%u", SIGRTMIN, SIGRTMAX);
 882                 return -EINVAL;
 883         }
 884
 885         assert_se(ignore_signals(SIGRTMIN + 1, -1) >= 0);
 886         assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGRTMIN, -1) >= 0);
 887
 888         r = sd_event_add_signal(m->event, NULL, SIGRTMIN, manager_vt_switch, m);
 889         if (r < 0)
 890                 return r;
 891
 892         return 0;
 893 }
 894
 895 static int manager_connect_udev(Manager *m) {
 896         int r;
 897
 898         assert(m);
 899         assert(!m->udev_seat_monitor);
 900         assert(!m->udev_device_monitor);
 901         assert(!m->udev_vcsa_monitor);
 902         assert(!m->udev_button_monitor);
 903
 904         m->udev_seat_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
 905         if (!m->udev_seat_monitor)
 906                 return -ENOMEM;
 907
 908         r = udev_monitor_filter_add_match_tag(m->udev_seat_monitor, "master-of-seat");
 909         if (r < 0)
 910                 return r;
 911
 912         r = udev_monitor_enable_receiving(m->udev_seat_monitor);
 913         if (r < 0)
 914                 return r;
 915
 916         r = sd_event_add_io(m->event, &m->udev_seat_event_source, udev_monitor_get_fd(m->udev_seat_monitor), EPOLLIN, manager_dispatch_seat_udev, m);
 917         if (r < 0)
 918                 return r;
 919
 920         m->udev_device_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
 921         if (!m->udev_device_monitor)
 922                 return -ENOMEM;
 923
 924         r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_device_monitor, "input", NULL);
 925         if (r < 0)
 926                 return r;
 927
 928         r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_device_monitor, "graphics", NULL);
 929         if (r < 0)
 930                 return r;
 931
 932         r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_device_monitor, "drm", NULL);
 933         if (r < 0)
 934                 return r;
 935
 936         r = udev_monitor_enable_receiving(m->udev_device_monitor);
 937         if (r < 0)
 938                 return r;
 939
 940         r = sd_event_add_io(m->event, &m->udev_device_event_source, udev_monitor_get_fd(m->udev_device_monitor), EPOLLIN, manager_dispatch_device_udev, m);
 941         if (r < 0)
 942                 return r;
 943
 944         /* Don't watch keys if nobody cares */
 945         if (!manager_all_buttons_ignored(m)) {
 946                 m->udev_button_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
 947                 if (!m->udev_button_monitor)
 948                         return -ENOMEM;
 949
 950                 r = udev_monitor_filter_add_match_tag(m->udev_button_monitor, "power-switch");
 951                 if (r < 0)
 952                         return r;
 953
 954                 r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_button_monitor, "input", NULL);
 955                 if (r < 0)
 956                         return r;
 957
 958                 r = udev_monitor_enable_receiving(m->udev_button_monitor);
 959                 if (r < 0)
 960                         return r;
 961
 962                 r = sd_event_add_io(m->event, &m->udev_button_event_source, udev_monitor_get_fd(m->udev_button_monitor), EPOLLIN, manager_dispatch_button_udev, m);
 963                 if (r < 0)
 964                         return r;
 965         }
 966
 967         /* Don't bother watching VCSA devices, if nobody cares */
 968 #if 0 /// elogind does not support autospawning of vts
 969         if (m->n_autovts > 0 && m->console_active_fd >= 0) {
 970
 971                 m->udev_vcsa_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
 972                 if (!m->udev_vcsa_monitor)
 973                         return -ENOMEM;
 974
 975                 r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_vcsa_monitor, "vc", NULL);
 976                 if (r < 0)
 977                         return r;
 978
 979                 r = udev_monitor_enable_receiving(m->udev_vcsa_monitor);
 980                 if (r < 0)
 981                         return r;
 982
 983                 r = sd_event_add_io(m->event, &m->udev_vcsa_event_source, udev_monitor_get_fd(m->udev_vcsa_monitor), EPOLLIN, manager_dispatch_vcsa_udev, m);
 984                 if (r < 0)
 985                         return r;
 986         }
 987 #endif // 0
 988
 989         return 0;
 990 }
 991
 992 static void manager_gc(Manager *m, bool drop_not_started) {
 993         Seat *seat;
 994         Session *session;
 995         User *user;
 996
 997         assert(m);
 998
 999         while ((seat = m->seat_gc_queue)) {
1000                 LIST_REMOVE(gc_queue, m->seat_gc_queue, seat);
1001                 seat->in_gc_queue = false;
1002
1003                 if (seat_may_gc(seat, drop_not_started)) {
1004                         seat_stop(seat, false);
1005                         seat_free(seat);
1006                 }
1007         }
1008
1009         while ((session = m->session_gc_queue)) {
1010                 LIST_REMOVE(gc_queue, m->session_gc_queue, session);
1011                 session->in_gc_queue = false;
1012
1013                 /* First, if we are not closing yet, initiate stopping */
1014                 if (session_may_gc(session, drop_not_started) &&
1015                     session_get_state(session) != SESSION_CLOSING)
1016                         session_stop(session, false);
1017
1018                 /* Normally, this should make the session referenced
1019                  * again, if it doesn't then let's get rid of it
1020                  * immediately */
1021                 if (session_may_gc(session, drop_not_started)) {
1022                         session_finalize(session);
1023                         session_free(session);
1024                 }
1025         }
1026
1027         while ((user = m->user_gc_queue)) {
1028                 LIST_REMOVE(gc_queue, m->user_gc_queue, user);
1029                 user->in_gc_queue = false;
1030
1031                 /* First step: queue stop jobs */
1032                 if (user_may_gc(user, drop_not_started))
1033                         user_stop(user, false);
1034
1035                 /* Second step: finalize user */
1036                 if (user_may_gc(user, drop_not_started)) {
1037                         user_finalize(user);
1038                         user_free(user);
1039                 }
1040         }
1041 }
1042
1043 static int manager_dispatch_idle_action(sd_event_source *s, uint64_t t, void *userdata) {
1044         Manager *m = userdata;
1045         struct dual_timestamp since;
1046         usec_t n, elapse;
1047         int r;
1048
1049         assert(m);
1050
1051         if (m->idle_action == HANDLE_IGNORE ||
1052             m->idle_action_usec <= 0)
1053                 return 0;
1054
1055         n = now(CLOCK_MONOTONIC);
1056
1057         r = manager_get_idle_hint(m, &since);
1058         if (r <= 0)
1059                 /* Not idle. Let's check if after a timeout it might be idle then. */
1060                 elapse = n + m->idle_action_usec;
1061         else {
1062                 /* Idle! Let's see if it's time to do something, or if
1063                  * we shall sleep for longer. */
1064
1065                 if (n >= since.monotonic + m->idle_action_usec &&
1066                     (m->idle_action_not_before_usec <= 0 || n >= m->idle_action_not_before_usec + m->idle_action_usec)) {
1067                         log_info("System idle. Taking action.");
1068
1069                         manager_handle_action(m, 0, m->idle_action, false, false);
1070                         m->idle_action_not_before_usec = n;
1071                 }
1072
1073                 elapse = MAX(since.monotonic, m->idle_action_not_before_usec) + m->idle_action_usec;
1074         }
1075
1076         if (!m->idle_action_event_source) {
1077
1078                 r = sd_event_add_time(
1079                                 m->event,
1080                                 &m->idle_action_event_source,
1081                                 CLOCK_MONOTONIC,
1082                                 elapse, USEC_PER_SEC*30,
1083                                 manager_dispatch_idle_action, m);
1084                 if (r < 0)
1085                         return log_error_errno(r, "Failed to add idle event source: %m");
1086
1087                 r = sd_event_source_set_priority(m->idle_action_event_source, SD_EVENT_PRIORITY_IDLE+10);
1088                 if (r < 0)
1089                         return log_error_errno(r, "Failed to set idle event source priority: %m");
1090         } else {
1091                 r = sd_event_source_set_time(m->idle_action_event_source, elapse);
1092                 if (r < 0)
1093                         return log_error_errno(r, "Failed to set idle event timer: %m");
1094
1095                 r = sd_event_source_set_enabled(m->idle_action_event_source, SD_EVENT_ONESHOT);
1096                 if (r < 0)
1097                         return log_error_errno(r, "Failed to enable idle event timer: %m");
1098         }
1099
1100         return 0;
1101 }
1102
1103 #if 0 /// elogind parses its own config file
1104 #else
1105          const char* logind_conf = getenv("ELOGIND_CONF_FILE");
1106
1107          assert(m);
1108
1109          if (!logind_conf)
1110                  logind_conf = PKGSYSCONFDIR "/logind.conf";
1111
1112          return config_parse(NULL, logind_conf, NULL, "Login\0Sleep\0",
1113                              config_item_perf_lookup, logind_gperf_lookup,
1114 #endif // 0
1115 static int manager_dispatch_reload_signal(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
1116         Manager *m = userdata;
1117         int r;
1118
1119         manager_reset_config(m);
1120         r = manager_parse_config_file(m);
1121         if (r < 0)
1122                 log_warning_errno(r, "Failed to parse config file, using defaults: %m");
1123         else
1124                 log_info("Config file reloaded.");
1125
1126 #if 1 /// elogind needs an Add-On for sleep configuration
1127         elogind_manager_reset_config(m);
1128 #endif // 1
1129         return 0;
1130 }
1131
1132 static int manager_startup(Manager *m) {
1133         int r;
1134         Seat *seat;
1135         Session *session;
1136         User *user;
1137         Button *button;
1138         Inhibitor *inhibitor;
1139         Iterator i;
1140
1141         assert(m);
1142
1143         assert_se(sigprocmask_many(SIG_SETMASK, NULL, SIGHUP, -1) >= 0);
1144
1145         r = sd_event_add_signal(m->event, NULL, SIGHUP, manager_dispatch_reload_signal, m);
1146         if (r < 0)
1147                 return log_error_errno(r, "Failed to register SIGHUP handler: %m");
1148
1149 #if 1 /// elogind needs some extra preparations before connecting...
1150         elogind_manager_startup(m);
1151 #endif // 1
1152         /* Connect to console */
1153         r = manager_connect_console(m);
1154         if (r < 0)
1155                 return r;
1156
1157         /* Connect to udev */
1158         r = manager_connect_udev(m);
1159         if (r < 0)
1160                 return log_error_errno(r, "Failed to create udev watchers: %m");
1161
1162         /* Connect to the bus */
1163         r = manager_connect_bus(m);
1164         if (r < 0)
1165                 return r;
1166
1167         /* Instantiate magic seat 0 */
1168         r = manager_add_seat(m, "seat0", &m->seat0);
1169         if (r < 0)
1170                 return log_error_errno(r, "Failed to add seat0: %m");
1171
1172         r = manager_set_lid_switch_ignore(m, 0 + m->holdoff_timeout_usec);
1173         if (r < 0)
1174                 log_warning_errno(r, "Failed to set up lid switch ignore event source: %m");
1175
1176         /* Deserialize state */
1177         r = manager_enumerate_devices(m);
1178         if (r < 0)
1179                 log_warning_errno(r, "Device enumeration failed: %m");
1180
1181         r = manager_enumerate_seats(m);
1182         if (r < 0)
1183                 log_warning_errno(r, "Seat enumeration failed: %m");
1184
1185         r = manager_enumerate_users(m);
1186         if (r < 0)
1187                 log_warning_errno(r, "User enumeration failed: %m");
1188
1189         r = manager_enumerate_sessions(m);
1190         if (r < 0)
1191                 log_warning_errno(r, "Session enumeration failed: %m");
1192
1193         r = manager_enumerate_inhibitors(m);
1194         if (r < 0)
1195                 log_warning_errno(r, "Inhibitor enumeration failed: %m");
1196
1197         r = manager_enumerate_buttons(m);
1198         if (r < 0)
1199                 log_warning_errno(r, "Button enumeration failed: %m");
1200
1201         /* Remove stale objects before we start them */
1202         manager_gc(m, false);
1203
1204         /* Reserve the special reserved VT */
1205 #if 0 /// elogind does not support autospawning of vts
1206         manager_reserve_vt(m);
1207 #endif // 0
1208
1209         /* And start everything */
1210         HASHMAP_FOREACH(seat, m->seats, i)
1211                 seat_start(seat);
1212
1213         HASHMAP_FOREACH(user, m->users, i)
1214                 user_start(user);
1215
1216         HASHMAP_FOREACH(session, m->sessions, i)
1217                 session_start(session, NULL);
1218
1219         HASHMAP_FOREACH(inhibitor, m->inhibitors, i)
1220                 inhibitor_start(inhibitor);
1221
1222         HASHMAP_FOREACH(button, m->buttons, i)
1223                 button_check_switches(button);
1224
1225         manager_dispatch_idle_action(NULL, 0, m);
1226
1227         return 0;
1228 }
1229
1230 static int manager_run(Manager *m) {
1231         int r;
1232
1233         assert(m);
1234
1235         for (;;) {
1236                 r = sd_event_get_state(m->event);
1237                 if (r < 0)
1238                         return r;
1239                 if (r == SD_EVENT_FINISHED)
1240                         return 0;
1241
1242                 manager_gc(m, true);
1243
1244                 r = manager_dispatch_delayed(m, false);
1245                 if (r < 0)
1246                         return r;
1247                 if (r > 0)
1248                         continue;
1249
1250                 r = sd_event_run(m->event, (uint64_t) -1);
1251                 if (r < 0)
1252                         return r;
1253         }
1254 }
1255
1256 int main(int argc, char *argv[]) {
1257         _cleanup_(manager_unrefp) Manager *m = NULL;
1258         int r;
1259
1260 #if 1 /// perform extra checks for elogind startup
1261         r = elogind_startup(argc, argv);
1262         if (r)
1263                 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1264 #endif // 1
1265         elogind_set_program_name(argv[0]);
1266         log_set_target(LOG_TARGET_AUTO);
1267         log_set_facility(LOG_AUTH);
1268         log_parse_environment();
1269 #if ENABLE_DEBUG_ELOGIND
1270         log_set_max_level(LOG_DEBUG);
1271         log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1272 #endif // ENABLE_DEBUG_ELOGIND
1273         log_open();
1274
1275         umask(0022);
1276
1277 #if 0 /// elogind has some extra functionality at startup, argc can be != 1
1278         if (argc != 1) {
1279                 log_error("This program takes no arguments.");
1280                 r = -EINVAL;
1281                 goto finish;
1282         }
1283 #endif // 0
1284
1285         r = mac_selinux_init();
1286         if (r < 0) {
1287                 log_error_errno(r, "Could not initialize labelling: %m");
1288                 goto finish;
1289         }
1290
1291         /* Always create the directories people can create inotify
1292          * watches in. Note that some applications might check for the
1293          * existence of /run/systemd/seats/ to determine whether
1294          * logind is available, so please always make sure this check
1295          * stays in. */
1296 #if 0 /// elogind can not rely on systemd to help, so we need a bit more effort than this
1297         mkdir_label("/run/systemd/seats", 0755);
1298         mkdir_label("/run/systemd/users", 0755);
1299         mkdir_label("/run/systemd/sessions", 0755);
1300
1301         r = manager_new(&m);
1302         if (r < 0) {
1303                 log_error_errno(r, "Failed to allocate manager object: %m");
1304 #else
1305         r = mkdir_label("/run/systemd", 0755);
1306         if ( (r < 0) && (-EEXIST != r) )
1307                 return log_error_errno(r, "Failed to create /run/systemd : %m");
1308         r = mkdir_label("/run/systemd/seats", 0755);
1309         if ( r < 0 && (-EEXIST != r) )
1310                 return log_error_errno(r, "Failed to create /run/systemd/seats : %m");
1311         r = mkdir_label("/run/systemd/users", 0755);
1312         if ( r < 0 && (-EEXIST != r) )
1313                 return log_error_errno(r, "Failed to create /run/systemd/users : %m");
1314         r = mkdir_label("/run/systemd/sessions", 0755);
1315         if ( r < 0 && (-EEXIST != r) )
1316                 return log_error_errno(r, "Failed to create /run/systemd/sessions : %m");
1317         r = mkdir_label("/run/systemd/machines", 0755);
1318         if ( r < 0 && (-EEXIST != r) )
1319                 return log_error_errno(r, "Failed to create /run/systemd/machines : %m");
1320 #endif // 0
1321                 goto finish;
1322         }
1323
1324         (void) manager_parse_config_file(m);
1325
1326 #if 1 /// elogind needs an Add-On for sleep configuration
1327         elogind_manager_reset_config(m);
1328 #endif // 1
1329         r = manager_startup(m);
1330         if (r < 0) {
1331                 log_error_errno(r, "Failed to fully start up daemon: %m");
1332                 goto finish;
1333         }
1334
1335         log_debug("elogind running as pid "PID_FMT, getpid_cached());
1336
1337         (void) sd_notify(false,
1338                          "READY=1\n"
1339                          "STATUS=Processing requests...");
1340
1341         r = manager_run(m);
1342
1343         log_debug("elogind stopped as pid "PID_FMT, getpid_cached());
1344
1345         (void) sd_notify(false,
1346                          "STOPPING=1\n"
1347                          "STATUS=Shutting down...");
1348
1349 finish:
1350         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1351 }