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