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