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