src/login/logind.c

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