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