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