src/login/logind.c

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