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 <pwd.h>
  24 #include <libudev.h>
  25 #include <fcntl.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28 #include <sys/epoll.h>
  29 #include <sys/ioctl.h>
  30 #include <linux/vt.h>
  31 #include <sys/timerfd.h>
  32
  33 #include <systemd/sd-daemon.h>
  34
  35 #include "logind.h"
  36 #include "dbus-common.h"
  37 #include "dbus-loop.h"
  38 #include "strv.h"
  39 #include "conf-parser.h"
  40 #include "mkdir.h"
  41
  42 Manager *manager_new(void) {
  43         Manager *m;
  44
  45         m = new0(Manager, 1);
  46         if (!m)
  47                 return NULL;
  48
  49         m->console_active_fd = -1;
  50         m->bus_fd = -1;
  51         m->udev_seat_fd = -1;
  52         m->udev_vcsa_fd = -1;
  53         m->udev_button_fd = -1;
  54         m->epoll_fd = -1;
  55         m->reserve_vt_fd = -1;
  56
  57         m->n_autovts = 6;
  58         m->reserve_vt = 6;
  59         m->inhibit_delay_max = 5 * USEC_PER_SEC;
  60         m->handle_power_key = HANDLE_POWEROFF;
  61         m->handle_suspend_key = HANDLE_SUSPEND;
  62         m->handle_hibernate_key = HANDLE_HIBERNATE;
  63         m->handle_lid_switch = HANDLE_SUSPEND;
  64         m->lid_switch_ignore_inhibited = true;
  65
  66         m->idle_action_fd = -1;
  67         m->idle_action_usec = 30 * USEC_PER_MINUTE;
  68         m->idle_action = HANDLE_IGNORE;
  69         m->idle_action_not_before_usec = now(CLOCK_MONOTONIC);
  70
  71         m->devices = hashmap_new(string_hash_func, string_compare_func);
  72         m->seats = hashmap_new(string_hash_func, string_compare_func);
  73         m->sessions = hashmap_new(string_hash_func, string_compare_func);
  74         m->users = hashmap_new(trivial_hash_func, trivial_compare_func);
  75         m->inhibitors = hashmap_new(string_hash_func, string_compare_func);
  76         m->buttons = hashmap_new(string_hash_func, string_compare_func);
  77
  78         m->user_cgroups = hashmap_new(string_hash_func, string_compare_func);
  79         m->session_cgroups = hashmap_new(string_hash_func, string_compare_func);
  80
  81         m->session_fds = hashmap_new(trivial_hash_func, trivial_compare_func);
  82         m->inhibitor_fds = hashmap_new(trivial_hash_func, trivial_compare_func);
  83         m->button_fds = hashmap_new(trivial_hash_func, trivial_compare_func);
  84
  85         if (!m->devices || !m->seats || !m->sessions || !m->users || !m->inhibitors || !m->buttons ||
  86             !m->user_cgroups || !m->session_cgroups ||
  87             !m->session_fds || !m->inhibitor_fds || !m->button_fds) {
  88                 manager_free(m);
  89                 return NULL;
  90         }
  91
  92         m->reset_controllers = strv_new("cpu", NULL);
  93         m->kill_exclude_users = strv_new("root", NULL);
  94         if (!m->reset_controllers || !m->kill_exclude_users) {
  95                 manager_free(m);
  96                 return NULL;
  97         }
  98
  99         m->udev = udev_new();
 100         if (!m->udev) {
 101                 manager_free(m);
 102                 return NULL;
 103         }
 104
 105         if (cg_get_user_path(&m->cgroup_path) < 0) {
 106                 manager_free(m);
 107                 return NULL;
 108         }
 109
 110         return m;
 111 }
 112
 113 void manager_free(Manager *m) {
 114         Session *session;
 115         User *u;
 116         Device *d;
 117         Seat *s;
 118         Inhibitor *i;
 119         Button *b;
 120
 121         assert(m);
 122
 123         while ((session = hashmap_first(m->sessions)))
 124                 session_free(session);
 125
 126         while ((u = hashmap_first(m->users)))
 127                 user_free(u);
 128
 129         while ((d = hashmap_first(m->devices)))
 130                 device_free(d);
 131
 132         while ((s = hashmap_first(m->seats)))
 133                 seat_free(s);
 134
 135         while ((i = hashmap_first(m->inhibitors)))
 136                 inhibitor_free(i);
 137
 138         while ((b = hashmap_first(m->buttons)))
 139                 button_free(b);
 140
 141         hashmap_free(m->devices);
 142         hashmap_free(m->seats);
 143         hashmap_free(m->sessions);
 144         hashmap_free(m->users);
 145         hashmap_free(m->inhibitors);
 146         hashmap_free(m->buttons);
 147
 148         hashmap_free(m->user_cgroups);
 149         hashmap_free(m->session_cgroups);
 150
 151         hashmap_free(m->session_fds);
 152         hashmap_free(m->inhibitor_fds);
 153         hashmap_free(m->button_fds);
 154
 155         if (m->console_active_fd >= 0)
 156                 close_nointr_nofail(m->console_active_fd);
 157
 158         if (m->udev_seat_monitor)
 159                 udev_monitor_unref(m->udev_seat_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         if (m->bus) {
 169                 dbus_connection_flush(m->bus);
 170                 dbus_connection_close(m->bus);
 171                 dbus_connection_unref(m->bus);
 172         }
 173
 174         if (m->bus_fd >= 0)
 175                 close_nointr_nofail(m->bus_fd);
 176
 177         if (m->epoll_fd >= 0)
 178                 close_nointr_nofail(m->epoll_fd);
 179
 180         if (m->reserve_vt_fd >= 0)
 181                 close_nointr_nofail(m->reserve_vt_fd);
 182
 183         if (m->idle_action_fd >= 0)
 184                 close_nointr_nofail(m->idle_action_fd);
 185
 186         strv_free(m->controllers);
 187         strv_free(m->reset_controllers);
 188         strv_free(m->kill_only_users);
 189         strv_free(m->kill_exclude_users);
 190
 191         free(m->action_job);
 192
 193         free(m->cgroup_path);
 194         free(m);
 195 }
 196
 197 int manager_add_device(Manager *m, const char *sysfs, Device **_device) {
 198         Device *d;
 199
 200         assert(m);
 201         assert(sysfs);
 202
 203         d = hashmap_get(m->devices, sysfs);
 204         if (d) {
 205                 if (_device)
 206                         *_device = d;
 207
 208                 return 0;
 209         }
 210
 211         d = device_new(m, sysfs);
 212         if (!d)
 213                 return -ENOMEM;
 214
 215         if (_device)
 216                 *_device = d;
 217
 218         return 0;
 219 }
 220
 221 int manager_add_seat(Manager *m, const char *id, Seat **_seat) {
 222         Seat *s;
 223
 224         assert(m);
 225         assert(id);
 226
 227         s = hashmap_get(m->seats, id);
 228         if (s) {
 229                 if (_seat)
 230                         *_seat = s;
 231
 232                 return 0;
 233         }
 234
 235         s = seat_new(m, id);
 236         if (!s)
 237                 return -ENOMEM;
 238
 239         if (_seat)
 240                 *_seat = s;
 241
 242         return 0;
 243 }
 244
 245 int manager_add_session(Manager *m, User *u, const char *id, Session **_session) {
 246         Session *s;
 247
 248         assert(m);
 249         assert(id);
 250
 251         s = hashmap_get(m->sessions, id);
 252         if (s) {
 253                 if (_session)
 254                         *_session = s;
 255
 256                 return 0;
 257         }
 258
 259         s = session_new(m, u, id);
 260         if (!s)
 261                 return -ENOMEM;
 262
 263         if (_session)
 264                 *_session = s;
 265
 266         return 0;
 267 }
 268
 269 int manager_add_user(Manager *m, uid_t uid, gid_t gid, const char *name, User **_user) {
 270         User *u;
 271
 272         assert(m);
 273         assert(name);
 274
 275         u = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
 276         if (u) {
 277                 if (_user)
 278                         *_user = u;
 279
 280                 return 0;
 281         }
 282
 283         u = user_new(m, uid, gid, name);
 284         if (!u)
 285                 return -ENOMEM;
 286
 287         if (_user)
 288                 *_user = u;
 289
 290         return 0;
 291 }
 292
 293 int manager_add_user_by_name(Manager *m, const char *name, User **_user) {
 294         uid_t uid;
 295         gid_t gid;
 296         int r;
 297
 298         assert(m);
 299         assert(name);
 300
 301         r = get_user_creds(&name, &uid, &gid, NULL, NULL);
 302         if (r < 0)
 303                 return r;
 304
 305         return manager_add_user(m, uid, gid, name, _user);
 306 }
 307
 308 int manager_add_user_by_uid(Manager *m, uid_t uid, User **_user) {
 309         struct passwd *p;
 310
 311         assert(m);
 312
 313         errno = 0;
 314         p = getpwuid(uid);
 315         if (!p)
 316                 return errno ? -errno : -ENOENT;
 317
 318         return manager_add_user(m, uid, p->pw_gid, p->pw_name, _user);
 319 }
 320
 321 int manager_add_inhibitor(Manager *m, const char* id, Inhibitor **_inhibitor) {
 322         Inhibitor *i;
 323
 324         assert(m);
 325         assert(id);
 326
 327         i = hashmap_get(m->inhibitors, id);
 328         if (i) {
 329                 if (_inhibitor)
 330                         *_inhibitor = i;
 331
 332                 return 0;
 333         }
 334
 335         i = inhibitor_new(m, id);
 336         if (!i)
 337                 return -ENOMEM;
 338
 339         if (_inhibitor)
 340                 *_inhibitor = i;
 341
 342         return 0;
 343 }
 344
 345 int manager_add_button(Manager *m, const char *name, Button **_button) {
 346         Button *b;
 347
 348         assert(m);
 349         assert(name);
 350
 351         b = hashmap_get(m->buttons, name);
 352         if (b) {
 353                 if (_button)
 354                         *_button = b;
 355
 356                 return 0;
 357         }
 358
 359         b = button_new(m, name);
 360         if (!b)
 361                 return -ENOMEM;
 362
 363         if (_button)
 364                 *_button = b;
 365
 366         return 0;
 367 }
 368
 369 int manager_process_seat_device(Manager *m, struct udev_device *d) {
 370         Device *device;
 371         int r;
 372
 373         assert(m);
 374
 375         if (streq_ptr(udev_device_get_action(d), "remove")) {
 376
 377                 device = hashmap_get(m->devices, udev_device_get_syspath(d));
 378                 if (!device)
 379                         return 0;
 380
 381                 seat_add_to_gc_queue(device->seat);
 382                 device_free(device);
 383
 384         } else {
 385                 const char *sn;
 386                 Seat *seat;
 387
 388                 sn = udev_device_get_property_value(d, "ID_SEAT");
 389                 if (isempty(sn))
 390                         sn = "seat0";
 391
 392                 if (!seat_name_is_valid(sn)) {
 393                         log_warning("Device with invalid seat name %s found, ignoring.", sn);
 394                         return 0;
 395                 }
 396
 397                 r = manager_add_device(m, udev_device_get_syspath(d), &device);
 398                 if (r < 0)
 399                         return r;
 400
 401                 r = manager_add_seat(m, sn, &seat);
 402                 if (r < 0) {
 403                         if (!device->seat)
 404                                 device_free(device);
 405
 406                         return r;
 407                 }
 408
 409                 device_attach(device, seat);
 410                 seat_start(seat);
 411         }
 412
 413         return 0;
 414 }
 415
 416 int manager_process_button_device(Manager *m, struct udev_device *d) {
 417         Button *b;
 418
 419         int r;
 420
 421         assert(m);
 422
 423         if (streq_ptr(udev_device_get_action(d), "remove")) {
 424
 425                 b = hashmap_get(m->buttons, udev_device_get_sysname(d));
 426                 if (!b)
 427                         return 0;
 428
 429                 button_free(b);
 430
 431         } else {
 432                 const char *sn;
 433
 434                 r = manager_add_button(m, udev_device_get_sysname(d), &b);
 435                 if (r < 0)
 436                         return r;
 437
 438                 sn = udev_device_get_property_value(d, "ID_SEAT");
 439                 if (isempty(sn))
 440                         sn = "seat0";
 441
 442                 button_set_seat(b, sn);
 443                 button_open(b);
 444         }
 445
 446         return 0;
 447 }
 448
 449 int manager_enumerate_devices(Manager *m) {
 450         struct udev_list_entry *item = NULL, *first = NULL;
 451         struct udev_enumerate *e;
 452         int r;
 453
 454         assert(m);
 455
 456         /* Loads devices from udev and creates seats for them as
 457          * necessary */
 458
 459         e = udev_enumerate_new(m->udev);
 460         if (!e) {
 461                 r = -ENOMEM;
 462                 goto finish;
 463         }
 464
 465         r = udev_enumerate_add_match_tag(e, "master-of-seat");
 466         if (r < 0)
 467                 goto finish;
 468
 469         r = udev_enumerate_scan_devices(e);
 470         if (r < 0)
 471                 goto finish;
 472
 473         first = udev_enumerate_get_list_entry(e);
 474         udev_list_entry_foreach(item, first) {
 475                 struct udev_device *d;
 476                 int k;
 477
 478                 d = udev_device_new_from_syspath(m->udev, udev_list_entry_get_name(item));
 479                 if (!d) {
 480                         r = -ENOMEM;
 481                         goto finish;
 482                 }
 483
 484                 k = manager_process_seat_device(m, d);
 485                 udev_device_unref(d);
 486
 487                 if (k < 0)
 488                         r = k;
 489         }
 490
 491 finish:
 492         if (e)
 493                 udev_enumerate_unref(e);
 494
 495         return r;
 496 }
 497
 498 int manager_enumerate_buttons(Manager *m) {
 499         struct udev_list_entry *item = NULL, *first = NULL;
 500         struct udev_enumerate *e;
 501         int r;
 502
 503         assert(m);
 504
 505         /* Loads buttons from udev */
 506
 507         if (m->handle_power_key == HANDLE_IGNORE &&
 508             m->handle_suspend_key == HANDLE_IGNORE &&
 509             m->handle_hibernate_key == HANDLE_IGNORE &&
 510             m->handle_lid_switch == HANDLE_IGNORE)
 511                 return 0;
 512
 513         e = udev_enumerate_new(m->udev);
 514         if (!e) {
 515                 r = -ENOMEM;
 516                 goto finish;
 517         }
 518
 519         r = udev_enumerate_add_match_subsystem(e, "input");
 520         if (r < 0)
 521                 goto finish;
 522
 523         r = udev_enumerate_add_match_tag(e, "power-switch");
 524         if (r < 0)
 525                 goto finish;
 526
 527         r = udev_enumerate_scan_devices(e);
 528         if (r < 0)
 529                 goto finish;
 530
 531         first = udev_enumerate_get_list_entry(e);
 532         udev_list_entry_foreach(item, first) {
 533                 struct udev_device *d;
 534                 int k;
 535
 536                 d = udev_device_new_from_syspath(m->udev, udev_list_entry_get_name(item));
 537                 if (!d) {
 538                         r = -ENOMEM;
 539                         goto finish;
 540                 }
 541
 542                 k = manager_process_button_device(m, d);
 543                 udev_device_unref(d);
 544
 545                 if (k < 0)
 546                         r = k;
 547         }
 548
 549 finish:
 550         if (e)
 551                 udev_enumerate_unref(e);
 552
 553         return r;
 554 }
 555
 556 int manager_enumerate_seats(Manager *m) {
 557         DIR *d;
 558         struct dirent *de;
 559         int r = 0;
 560
 561         assert(m);
 562
 563         /* This loads data about seats stored on disk, but does not
 564          * actually create any seats. Removes data of seats that no
 565          * longer exist. */
 566
 567         d = opendir("/run/systemd/seats");
 568         if (!d) {
 569                 if (errno == ENOENT)
 570                         return 0;
 571
 572                 log_error("Failed to open /run/systemd/seats: %m");
 573                 return -errno;
 574         }
 575
 576         while ((de = readdir(d))) {
 577                 Seat *s;
 578                 int k;
 579
 580                 if (!dirent_is_file(de))
 581                         continue;
 582
 583                 s = hashmap_get(m->seats, de->d_name);
 584                 if (!s) {
 585                         unlinkat(dirfd(d), de->d_name, 0);
 586                         continue;
 587                 }
 588
 589                 k = seat_load(s);
 590                 if (k < 0)
 591                         r = k;
 592         }
 593
 594         closedir(d);
 595
 596         return r;
 597 }
 598
 599 static int manager_enumerate_users_from_cgroup(Manager *m) {
 600         int r = 0, k;
 601         char *name;
 602         DIR *d;
 603
 604         r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, m->cgroup_path, &d);
 605         if (r < 0) {
 606                 if (r == -ENOENT)
 607                         return 0;
 608
 609                 log_error("Failed to open %s: %s", m->cgroup_path, strerror(-r));
 610                 return r;
 611         }
 612
 613         while ((k = cg_read_subgroup(d, &name)) > 0) {
 614                 User *user;
 615
 616                 k = manager_add_user_by_name(m, name, &user);
 617                 if (k < 0) {
 618                         free(name);
 619                         r = k;
 620                         continue;
 621                 }
 622
 623                 user_add_to_gc_queue(user);
 624
 625                 if (!user->cgroup_path)
 626                         if (asprintf(&user->cgroup_path, "%s/%s", m->cgroup_path, name) < 0) {
 627                                 r = -ENOMEM;
 628                                 free(name);
 629                                 break;
 630                         }
 631
 632                 free(name);
 633         }
 634
 635         if (r >= 0 && k < 0)
 636                 r = k;
 637
 638         closedir(d);
 639
 640         return r;
 641 }
 642
 643 static int manager_enumerate_linger_users(Manager *m) {
 644         DIR *d;
 645         struct dirent *de;
 646         int r = 0;
 647
 648         d = opendir("/var/lib/systemd/linger");
 649         if (!d) {
 650                 if (errno == ENOENT)
 651                         return 0;
 652
 653                 log_error("Failed to open /var/lib/systemd/linger/: %m");
 654                 return -errno;
 655         }
 656
 657         while ((de = readdir(d))) {
 658                 int k;
 659
 660                 if (!dirent_is_file(de))
 661                         continue;
 662
 663                 k = manager_add_user_by_name(m, de->d_name, NULL);
 664                 if (k < 0) {
 665                         log_notice("Couldn't add lingering user %s: %s", de->d_name, strerror(-k));
 666                         r = k;
 667                 }
 668         }
 669
 670         closedir(d);
 671
 672         return r;
 673 }
 674
 675 int manager_enumerate_users(Manager *m) {
 676         DIR *d;
 677         struct dirent *de;
 678         int r, k;
 679
 680         assert(m);
 681
 682         /* First, enumerate user cgroups */
 683         r = manager_enumerate_users_from_cgroup(m);
 684
 685         /* Second, add lingering users on top */
 686         k = manager_enumerate_linger_users(m);
 687         if (k < 0)
 688                 r = k;
 689
 690         /* Third, read in user data stored on disk */
 691         d = opendir("/run/systemd/users");
 692         if (!d) {
 693                 if (errno == ENOENT)
 694                         return 0;
 695
 696                 log_error("Failed to open /run/systemd/users: %m");
 697                 return -errno;
 698         }
 699
 700         while ((de = readdir(d))) {
 701                 uid_t uid;
 702                 User *u;
 703
 704                 if (!dirent_is_file(de))
 705                         continue;
 706
 707                 k = parse_uid(de->d_name, &uid);
 708                 if (k < 0) {
 709                         log_error("Failed to parse file name %s: %s", de->d_name, strerror(-k));
 710                         continue;
 711                 }
 712
 713                 u = hashmap_get(m->users, ULONG_TO_PTR(uid));
 714                 if (!u) {
 715                         unlinkat(dirfd(d), de->d_name, 0);
 716                         continue;
 717                 }
 718
 719                 k = user_load(u);
 720                 if (k < 0)
 721                         r = k;
 722         }
 723
 724         closedir(d);
 725
 726         return r;
 727 }
 728
 729 static int manager_enumerate_sessions_from_cgroup(Manager *m) {
 730         User *u;
 731         Iterator i;
 732         int r = 0;
 733
 734         HASHMAP_FOREACH(u, m->users, i) {
 735                 DIR *d;
 736                 char *name;
 737                 int k;
 738
 739                 if (!u->cgroup_path)
 740                         continue;
 741
 742                 k = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, &d);
 743                 if (k < 0) {
 744                         if (k == -ENOENT)
 745                                 continue;
 746
 747                         log_error("Failed to open %s: %s", u->cgroup_path, strerror(-k));
 748                         r = k;
 749                         continue;
 750                 }
 751
 752                 while ((k = cg_read_subgroup(d, &name)) > 0) {
 753                         Session *session;
 754
 755                         if (streq(name, "shared"))
 756                                 continue;
 757
 758                         k = manager_add_session(m, u, name, &session);
 759                         if (k < 0) {
 760                                 free(name);
 761                                 break;
 762                         }
 763
 764                         session_add_to_gc_queue(session);
 765
 766                         if (!session->cgroup_path)
 767                                 if (asprintf(&session->cgroup_path, "%s/%s", u->cgroup_path, name) < 0) {
 768                                         k = -ENOMEM;
 769                                         free(name);
 770                                         break;
 771                                 }
 772
 773                         free(name);
 774                 }
 775
 776                 closedir(d);
 777
 778                 if (k < 0)
 779                         r = k;
 780         }
 781
 782         return r;
 783 }
 784
 785 int manager_enumerate_sessions(Manager *m) {
 786         DIR *d;
 787         struct dirent *de;
 788         int r = 0;
 789
 790         assert(m);
 791
 792         /* First enumerate session cgroups */
 793         r = manager_enumerate_sessions_from_cgroup(m);
 794
 795         /* Second, read in session data stored on disk */
 796         d = opendir("/run/systemd/sessions");
 797         if (!d) {
 798                 if (errno == ENOENT)
 799                         return 0;
 800
 801                 log_error("Failed to open /run/systemd/sessions: %m");
 802                 return -errno;
 803         }
 804
 805         while ((de = readdir(d))) {
 806                 struct Session *s;
 807                 int k;
 808
 809                 if (!dirent_is_file(de))
 810                         continue;
 811
 812                 s = hashmap_get(m->sessions, de->d_name);
 813                 if (!s) {
 814                         unlinkat(dirfd(d), de->d_name, 0);
 815                         continue;
 816                 }
 817
 818                 k = session_load(s);
 819                 if (k < 0)
 820                         r = k;
 821         }
 822
 823         closedir(d);
 824
 825         return r;
 826 }
 827
 828 int manager_enumerate_inhibitors(Manager *m) {
 829         DIR *d;
 830         struct dirent *de;
 831         int r = 0;
 832
 833         assert(m);
 834
 835         d = opendir("/run/systemd/inhibit");
 836         if (!d) {
 837                 if (errno == ENOENT)
 838                         return 0;
 839
 840                 log_error("Failed to open /run/systemd/inhibit: %m");
 841                 return -errno;
 842         }
 843
 844         while ((de = readdir(d))) {
 845                 int k;
 846                 Inhibitor *i;
 847
 848                 if (!dirent_is_file(de))
 849                         continue;
 850
 851                 k = manager_add_inhibitor(m, de->d_name, &i);
 852                 if (k < 0) {
 853                         log_notice("Couldn't add inhibitor %s: %s", de->d_name, strerror(-k));
 854                         r = k;
 855                         continue;
 856                 }
 857
 858                 k = inhibitor_load(i);
 859                 if (k < 0)
 860                         r = k;
 861         }
 862
 863         closedir(d);
 864
 865         return r;
 866 }
 867
 868 int manager_dispatch_seat_udev(Manager *m) {
 869         struct udev_device *d;
 870         int r;
 871
 872         assert(m);
 873
 874         d = udev_monitor_receive_device(m->udev_seat_monitor);
 875         if (!d)
 876                 return -ENOMEM;
 877
 878         r = manager_process_seat_device(m, d);
 879         udev_device_unref(d);
 880
 881         return r;
 882 }
 883
 884 int manager_dispatch_vcsa_udev(Manager *m) {
 885         struct udev_device *d;
 886         int r = 0;
 887         const char *name;
 888
 889         assert(m);
 890
 891         d = udev_monitor_receive_device(m->udev_vcsa_monitor);
 892         if (!d)
 893                 return -ENOMEM;
 894
 895         name = udev_device_get_sysname(d);
 896
 897         /* Whenever a VCSA device is removed try to reallocate our
 898          * VTs, to make sure our auto VTs never go away. */
 899
 900         if (name && startswith(name, "vcsa") && streq_ptr(udev_device_get_action(d), "remove"))
 901                 r = seat_preallocate_vts(m->vtconsole);
 902
 903         udev_device_unref(d);
 904
 905         return r;
 906 }
 907
 908 int manager_dispatch_button_udev(Manager *m) {
 909         struct udev_device *d;
 910         int r;
 911
 912         assert(m);
 913
 914         d = udev_monitor_receive_device(m->udev_button_monitor);
 915         if (!d)
 916                 return -ENOMEM;
 917
 918         r = manager_process_button_device(m, d);
 919         udev_device_unref(d);
 920
 921         return r;
 922 }
 923
 924 int manager_dispatch_console(Manager *m) {
 925         assert(m);
 926
 927         if (m->vtconsole)
 928                 seat_read_active_vt(m->vtconsole);
 929
 930         return 0;
 931 }
 932
 933 static int vt_is_busy(int vtnr) {
 934         struct vt_stat vt_stat;
 935         int r = 0, fd;
 936
 937         assert(vtnr >= 1);
 938
 939         /* We explicitly open /dev/tty1 here instead of /dev/tty0. If
 940          * we'd open the latter we'd open the foreground tty which
 941          * hence would be unconditionally busy. By opening /dev/tty1
 942          * we avoid this. Since tty1 is special and needs to be an
 943          * explicitly loaded getty or DM this is safe. */
 944
 945         fd = open_terminal("/dev/tty1", O_RDWR|O_NOCTTY|O_CLOEXEC);
 946         if (fd < 0)
 947                 return -errno;
 948
 949         if (ioctl(fd, VT_GETSTATE, &vt_stat) < 0)
 950                 r = -errno;
 951         else
 952                 r = !!(vt_stat.v_state & (1 << vtnr));
 953
 954         close_nointr_nofail(fd);
 955
 956         return r;
 957 }
 958
 959 int manager_spawn_autovt(Manager *m, int vtnr) {
 960         int r;
 961         char *name = NULL;
 962         const char *mode = "fail";
 963
 964         assert(m);
 965         assert(vtnr >= 1);
 966
 967         if ((unsigned) vtnr > m->n_autovts &&
 968             (unsigned) vtnr != m->reserve_vt)
 969                 return 0;
 970
 971         if ((unsigned) vtnr != m->reserve_vt) {
 972                 /* If this is the reserved TTY, we'll start the getty
 973                  * on it in any case, but otherwise only if it is not
 974                  * busy. */
 975
 976                 r = vt_is_busy(vtnr);
 977                 if (r < 0)
 978                         return r;
 979                 else if (r > 0)
 980                         return -EBUSY;
 981         }
 982
 983         if (asprintf(&name, "autovt@tty%i.service", vtnr) < 0) {
 984                 log_error("Could not allocate service name.");
 985                 r = -ENOMEM;
 986                 goto finish;
 987         }
 988
 989         r = bus_method_call_with_reply (
 990                         m->bus,
 991                         "org.freedesktop.systemd1",
 992                         "/org/freedesktop/systemd1",
 993                         "org.freedesktop.systemd1.Manager",
 994                         "StartUnit",
 995                         NULL,
 996                         NULL,
 997                         DBUS_TYPE_STRING, &name,
 998                         DBUS_TYPE_STRING, &mode,
 999                         DBUS_TYPE_INVALID);
1000
1001 finish:
1002         free(name);
1003
1004         return r;
1005 }
1006
1007 static int manager_reserve_vt(Manager *m) {
1008         _cleanup_free_ char *p = NULL;
1009
1010         assert(m);
1011
1012         if (m->reserve_vt <= 0)
1013                 return 0;
1014
1015         if (asprintf(&p, "/dev/tty%u", m->reserve_vt) < 0)
1016                 return log_oom();
1017
1018         m->reserve_vt_fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC|O_NONBLOCK);
1019         if (m->reserve_vt_fd < 0) {
1020
1021                 /* Don't complain on VT-less systems */
1022                 if (errno != ENOENT)
1023                         log_warning("Failed to pin reserved VT: %m");
1024                 return -errno;
1025         }
1026
1027         return 0;
1028 }
1029
1030 int manager_get_session_by_cgroup(Manager *m, const char *cgroup, Session **session) {
1031         Session *s;
1032         char *p;
1033
1034         assert(m);
1035         assert(cgroup);
1036         assert(session);
1037
1038         s = hashmap_get(m->session_cgroups, cgroup);
1039         if (s) {
1040                 *session = s;
1041                 return 1;
1042         }
1043
1044         p = strdupa(cgroup);
1045
1046         for (;;) {
1047                 char *e;
1048
1049                 e = strrchr(p, '/');
1050                 if (!e || e == p) {
1051                         *session = NULL;
1052                         return 0;
1053                 }
1054
1055                 *e = 0;
1056
1057                 s = hashmap_get(m->session_cgroups, p);
1058                 if (s) {
1059                         *session = s;
1060                         return 1;
1061                 }
1062         }
1063 }
1064
1065 int manager_get_user_by_cgroup(Manager *m, const char *cgroup, User **user) {
1066         User *u;
1067         char *p;
1068
1069         assert(m);
1070         assert(cgroup);
1071         assert(user);
1072
1073         u = hashmap_get(m->user_cgroups, cgroup);
1074         if (u) {
1075                 *user = u;
1076                 return 1;
1077         }
1078
1079         p = strdupa(cgroup);
1080         if (!p)
1081                 return log_oom();
1082
1083         for (;;) {
1084                 char *e;
1085
1086                 e = strrchr(p, '/');
1087                 if (!e || e == p) {
1088                         *user = NULL;
1089                         return 0;
1090                 }
1091
1092                 *e = 0;
1093
1094                 u = hashmap_get(m->user_cgroups, p);
1095                 if (u) {
1096                         *user = u;
1097                         return 1;
1098                 }
1099         }
1100 }
1101
1102 int manager_get_session_by_pid(Manager *m, pid_t pid, Session **session) {
1103         _cleanup_free_ char *p = NULL;
1104         int r;
1105
1106         assert(m);
1107         assert(pid >= 1);
1108         assert(session);
1109
1110         r = cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, pid, &p);
1111         if (r < 0)
1112                 return r;
1113
1114         return manager_get_session_by_cgroup(m, p, session);
1115 }
1116
1117 void manager_cgroup_notify_empty(Manager *m, const char *cgroup) {
1118         Session *s;
1119         User *u;
1120         int r;
1121
1122         r = manager_get_session_by_cgroup(m, cgroup, &s);
1123         if (r > 0)
1124                 session_add_to_gc_queue(s);
1125
1126         r = manager_get_user_by_cgroup(m, cgroup, &u);
1127         if (r > 0)
1128                 user_add_to_gc_queue(u);
1129 }
1130
1131 static void manager_dispatch_other(Manager *m, int fd) {
1132         Session *s;
1133         Inhibitor *i;
1134         Button *b;
1135
1136         assert_se(m);
1137         assert_se(fd >= 0);
1138
1139         s = hashmap_get(m->session_fds, INT_TO_PTR(fd + 1));
1140         if (s) {
1141                 assert(s->fifo_fd == fd);
1142                 session_remove_fifo(s);
1143                 session_stop(s);
1144                 return;
1145         }
1146
1147         i = hashmap_get(m->inhibitor_fds, INT_TO_PTR(fd + 1));
1148         if (i) {
1149                 assert(i->fifo_fd == fd);
1150                 inhibitor_stop(i);
1151                 inhibitor_free(i);
1152                 return;
1153         }
1154
1155         b = hashmap_get(m->button_fds, INT_TO_PTR(fd + 1));
1156         if (b) {
1157                 assert(b->fd == fd);
1158                 button_process(b);
1159                 return;
1160         }
1161
1162         assert_not_reached("Got event for unknown fd");
1163 }
1164
1165 static int manager_connect_bus(Manager *m) {
1166         DBusError error;
1167         int r;
1168         struct epoll_event ev = {
1169                 .events = EPOLLIN,
1170                 .data.u32 = FD_BUS,
1171         };
1172
1173         assert(m);
1174         assert(!m->bus);
1175         assert(m->bus_fd < 0);
1176
1177         dbus_error_init(&error);
1178
1179         m->bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
1180         if (!m->bus) {
1181                 log_error("Failed to get system D-Bus connection: %s", bus_error_message(&error));
1182                 r = -ECONNREFUSED;
1183                 goto fail;
1184         }
1185
1186         if (!dbus_connection_register_object_path(m->bus, "/org/freedesktop/login1", &bus_manager_vtable, m) ||
1187             !dbus_connection_register_fallback(m->bus, "/org/freedesktop/login1/seat", &bus_seat_vtable, m) ||
1188             !dbus_connection_register_fallback(m->bus, "/org/freedesktop/login1/session", &bus_session_vtable, m) ||
1189             !dbus_connection_register_fallback(m->bus, "/org/freedesktop/login1/user", &bus_user_vtable, m) ||
1190             !dbus_connection_add_filter(m->bus, bus_message_filter, m, NULL)) {
1191                 r = log_oom();
1192                 goto fail;
1193         }
1194
1195         dbus_bus_add_match(m->bus,
1196                            "type='signal',"
1197                            "interface='org.freedesktop.systemd1.Agent',"
1198                            "member='Released',"
1199                            "path='/org/freedesktop/systemd1/agent'",
1200                            &error);
1201
1202         if (dbus_error_is_set(&error)) {
1203                 log_error("Failed to register match: %s", bus_error_message(&error));
1204                 r = -EIO;
1205                 goto fail;
1206         }
1207
1208         r = dbus_bus_request_name(m->bus, "org.freedesktop.login1", DBUS_NAME_FLAG_DO_NOT_QUEUE, &error);
1209         if (dbus_error_is_set(&error)) {
1210                 log_error("Failed to register name on bus: %s", bus_error_message(&error));
1211                 r = -EIO;
1212                 goto fail;
1213         }
1214
1215         if (r != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)  {
1216                 log_error("Failed to acquire name.");
1217                 r = -EEXIST;
1218                 goto fail;
1219         }
1220
1221         m->bus_fd = bus_loop_open(m->bus);
1222         if (m->bus_fd < 0) {
1223                 r = m->bus_fd;
1224                 goto fail;
1225         }
1226
1227         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->bus_fd, &ev) < 0)
1228                 goto fail;
1229
1230         return 0;
1231
1232 fail:
1233         dbus_error_free(&error);
1234
1235         return r;
1236 }
1237
1238 static int manager_connect_console(Manager *m) {
1239         struct epoll_event ev = {
1240                 .events = 0,
1241                 .data.u32 = FD_CONSOLE,
1242         };
1243
1244         assert(m);
1245         assert(m->console_active_fd < 0);
1246
1247         /* On certain architectures (S390 and Xen, and containers),
1248            /dev/tty0 does not exist, so don't fail if we can't open
1249            it. */
1250         if (access("/dev/tty0", F_OK) < 0) {
1251                 m->console_active_fd = -1;
1252                 return 0;
1253         }
1254
1255         m->console_active_fd = open("/sys/class/tty/tty0/active", O_RDONLY|O_NOCTTY|O_CLOEXEC);
1256         if (m->console_active_fd < 0) {
1257
1258                 /* On some systems the device node /dev/tty0 may exist
1259                  * even though /sys/class/tty/tty0 does not. */
1260                 if (errno == ENOENT)
1261                         return 0;
1262
1263                 log_error("Failed to open /sys/class/tty/tty0/active: %m");
1264                 return -errno;
1265         }
1266
1267         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->console_active_fd, &ev) < 0)
1268                 return -errno;
1269
1270         return 0;
1271 }
1272
1273 static int manager_connect_udev(Manager *m) {
1274         int r;
1275         struct epoll_event ev = {
1276                 .events = EPOLLIN,
1277                 .data.u32 = FD_SEAT_UDEV,
1278         };
1279
1280         assert(m);
1281         assert(!m->udev_seat_monitor);
1282         assert(!m->udev_vcsa_monitor);
1283         assert(!m->udev_button_monitor);
1284
1285         m->udev_seat_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
1286         if (!m->udev_seat_monitor)
1287                 return -ENOMEM;
1288
1289         r = udev_monitor_filter_add_match_tag(m->udev_seat_monitor, "master-of-seat");
1290         if (r < 0)
1291                 return r;
1292
1293         r = udev_monitor_enable_receiving(m->udev_seat_monitor);
1294         if (r < 0)
1295                 return r;
1296
1297         m->udev_seat_fd = udev_monitor_get_fd(m->udev_seat_monitor);
1298
1299         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_seat_fd, &ev) < 0)
1300                 return -errno;
1301
1302         /* Don't watch keys if nobody cares */
1303         if (m->handle_power_key != HANDLE_IGNORE ||
1304             m->handle_suspend_key != HANDLE_IGNORE ||
1305             m->handle_hibernate_key != HANDLE_IGNORE ||
1306             m->handle_lid_switch != HANDLE_IGNORE) {
1307
1308                 m->udev_button_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
1309                 if (!m->udev_button_monitor)
1310                         return -ENOMEM;
1311
1312                 r = udev_monitor_filter_add_match_tag(m->udev_button_monitor, "power-switch");
1313                 if (r < 0)
1314                         return r;
1315
1316                 r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_button_monitor, "input", NULL);
1317                 if (r < 0)
1318                         return r;
1319
1320                 r = udev_monitor_enable_receiving(m->udev_button_monitor);
1321                 if (r < 0)
1322                         return r;
1323
1324                 m->udev_button_fd = udev_monitor_get_fd(m->udev_button_monitor);
1325
1326                 zero(ev);
1327                 ev.events = EPOLLIN;
1328                 ev.data.u32 = FD_BUTTON_UDEV;
1329                 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_button_fd, &ev) < 0)
1330                         return -errno;
1331         }
1332
1333         /* Don't bother watching VCSA devices, if nobody cares */
1334         if (m->n_autovts > 0 && m->console_active_fd >= 0) {
1335
1336                 m->udev_vcsa_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
1337                 if (!m->udev_vcsa_monitor)
1338                         return -ENOMEM;
1339
1340                 r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_vcsa_monitor, "vc", NULL);
1341                 if (r < 0)
1342                         return r;
1343
1344                 r = udev_monitor_enable_receiving(m->udev_vcsa_monitor);
1345                 if (r < 0)
1346                         return r;
1347
1348                 m->udev_vcsa_fd = udev_monitor_get_fd(m->udev_vcsa_monitor);
1349
1350                 zero(ev);
1351                 ev.events = EPOLLIN;
1352                 ev.data.u32 = FD_VCSA_UDEV;
1353                 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_vcsa_fd, &ev) < 0)
1354                         return -errno;
1355         }
1356
1357         return 0;
1358 }
1359
1360 void manager_gc(Manager *m, bool drop_not_started) {
1361         Seat *seat;
1362         Session *session;
1363         User *user;
1364
1365         assert(m);
1366
1367         while ((seat = m->seat_gc_queue)) {
1368                 LIST_REMOVE(Seat, gc_queue, m->seat_gc_queue, seat);
1369                 seat->in_gc_queue = false;
1370
1371                 if (seat_check_gc(seat, drop_not_started) == 0) {
1372                         seat_stop(seat);
1373                         seat_free(seat);
1374                 }
1375         }
1376
1377         while ((session = m->session_gc_queue)) {
1378                 LIST_REMOVE(Session, gc_queue, m->session_gc_queue, session);
1379                 session->in_gc_queue = false;
1380
1381                 if (session_check_gc(session, drop_not_started) == 0) {
1382                         session_stop(session);
1383                         session_free(session);
1384                 }
1385         }
1386
1387         while ((user = m->user_gc_queue)) {
1388                 LIST_REMOVE(User, gc_queue, m->user_gc_queue, user);
1389                 user->in_gc_queue = false;
1390
1391                 if (user_check_gc(user, drop_not_started) == 0) {
1392                         user_stop(user);
1393                         user_free(user);
1394                 }
1395         }
1396 }
1397
1398 int manager_get_idle_hint(Manager *m, dual_timestamp *t) {
1399         Session *s;
1400         bool idle_hint;
1401         dual_timestamp ts = { 0, 0 };
1402         Iterator i;
1403
1404         assert(m);
1405
1406         idle_hint = !manager_is_inhibited(m, INHIBIT_IDLE, INHIBIT_BLOCK, t, false, false, 0);
1407
1408         HASHMAP_FOREACH(s, m->sessions, i) {
1409                 dual_timestamp k;
1410                 int ih;
1411
1412                 ih = session_get_idle_hint(s, &k);
1413                 if (ih < 0)
1414                         return ih;
1415
1416                 if (!ih) {
1417                         if (!idle_hint) {
1418                                 if (k.monotonic < ts.monotonic)
1419                                         ts = k;
1420                         } else {
1421                                 idle_hint = false;
1422                                 ts = k;
1423                         }
1424                 } else if (idle_hint) {
1425
1426                         if (k.monotonic > ts.monotonic)
1427                                 ts = k;
1428                 }
1429         }
1430
1431         if (t)
1432                 *t = ts;
1433
1434         return idle_hint;
1435 }
1436
1437 int manager_dispatch_idle_action(Manager *m) {
1438         struct dual_timestamp since;
1439         struct itimerspec its = {};
1440         int r;
1441         usec_t n;
1442
1443         assert(m);
1444
1445         if (m->idle_action == HANDLE_IGNORE ||
1446             m->idle_action_usec <= 0) {
1447                 r = 0;
1448                 goto finish;
1449         }
1450
1451         n = now(CLOCK_MONOTONIC);
1452
1453         r = manager_get_idle_hint(m, &since);
1454         if (r <= 0)
1455                 /* Not idle. Let's check if after a timeout it might be idle then. */
1456                 timespec_store(&its.it_value, n + m->idle_action_usec);
1457         else {
1458                 /* Idle! Let's see if it's time to do something, or if
1459                  * we shall sleep for longer. */
1460
1461                 if (n >= since.monotonic + m->idle_action_usec &&
1462                     (m->idle_action_not_before_usec <= 0 || n >= m->idle_action_not_before_usec + m->idle_action_usec)) {
1463                         log_info("System idle. Taking action.");
1464
1465                         manager_handle_action(m, 0, m->idle_action, false, false);
1466                         m->idle_action_not_before_usec = n;
1467                 }
1468
1469                 timespec_store(&its.it_value, MAX(since.monotonic, m->idle_action_not_before_usec) + m->idle_action_usec);
1470         }
1471
1472         if (m->idle_action_fd < 0) {
1473                 struct epoll_event ev = {
1474                         .events = EPOLLIN,
1475                         .data.u32 = FD_IDLE_ACTION,
1476                 };
1477
1478                 m->idle_action_fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
1479                 if (m->idle_action_fd < 0) {
1480                         log_error("Failed to create idle action timer: %m");
1481                         r = -errno;
1482                         goto finish;
1483                 }
1484
1485                 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->idle_action_fd, &ev) < 0) {
1486                         log_error("Failed to add idle action timer to epoll: %m");
1487                         r = -errno;
1488                         goto finish;
1489                 }
1490         }
1491
1492         if (timerfd_settime(m->idle_action_fd, TFD_TIMER_ABSTIME, &its, NULL) < 0) {
1493                 log_error("Failed to reset timerfd: %m");
1494                 r = -errno;
1495                 goto finish;
1496         }
1497
1498         return 0;
1499
1500 finish:
1501         if (m->idle_action_fd >= 0) {
1502                 close_nointr_nofail(m->idle_action_fd);
1503                 m->idle_action_fd = -1;
1504         }
1505
1506         return r;
1507 }
1508 int manager_startup(Manager *m) {
1509         int r;
1510         Seat *seat;
1511         Session *session;
1512         User *user;
1513         Inhibitor *inhibitor;
1514         Iterator i;
1515
1516         assert(m);
1517         assert(m->epoll_fd <= 0);
1518
1519         cg_shorten_controllers(m->reset_controllers);
1520         cg_shorten_controllers(m->controllers);
1521
1522         m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
1523         if (m->epoll_fd < 0)
1524                 return -errno;
1525
1526         /* Connect to console */
1527         r = manager_connect_console(m);
1528         if (r < 0)
1529                 return r;
1530
1531         /* Connect to udev */
1532         r = manager_connect_udev(m);
1533         if (r < 0)
1534                 return r;
1535
1536         /* Connect to the bus */
1537         r = manager_connect_bus(m);
1538         if (r < 0)
1539                 return r;
1540
1541         /* Instantiate magic seat 0 */
1542         r = manager_add_seat(m, "seat0", &m->vtconsole);
1543         if (r < 0)
1544                 return r;
1545
1546         /* Deserialize state */
1547         manager_enumerate_devices(m);
1548         manager_enumerate_seats(m);
1549         manager_enumerate_users(m);
1550         manager_enumerate_sessions(m);
1551         manager_enumerate_inhibitors(m);
1552         manager_enumerate_buttons(m);
1553
1554         /* Remove stale objects before we start them */
1555         manager_gc(m, false);
1556
1557         /* Reserve the special reserved VT */
1558         manager_reserve_vt(m);
1559
1560         /* And start everything */
1561         HASHMAP_FOREACH(seat, m->seats, i)
1562                 seat_start(seat);
1563
1564         HASHMAP_FOREACH(user, m->users, i)
1565                 user_start(user);
1566
1567         HASHMAP_FOREACH(session, m->sessions, i)
1568                 session_start(session);
1569
1570         HASHMAP_FOREACH(inhibitor, m->inhibitors, i)
1571                 inhibitor_start(inhibitor);
1572
1573         manager_dispatch_idle_action(m);
1574
1575         return 0;
1576 }
1577
1578 static int manager_recheck_buttons(Manager *m) {
1579         Iterator i;
1580         Button *b;
1581         int r = 0;
1582
1583         assert(m);
1584
1585         HASHMAP_FOREACH(b, m->buttons, i) {
1586                 int q;
1587
1588                 q = button_recheck(b);
1589                 if (q > 0)
1590                         return 1;
1591                 if (q < 0)
1592                         r = q;
1593         }
1594
1595         return r;
1596 }
1597
1598 int manager_run(Manager *m) {
1599         assert(m);
1600
1601         for (;;) {
1602                 struct epoll_event event;
1603                 int n;
1604                 int msec = -1;
1605
1606                 manager_gc(m, true);
1607
1608                 if (manager_dispatch_delayed(m) > 0)
1609                         continue;
1610
1611                 if (manager_recheck_buttons(m) > 0)
1612                         continue;
1613
1614                 if (dbus_connection_dispatch(m->bus) != DBUS_DISPATCH_COMPLETE)
1615                         continue;
1616
1617                 manager_gc(m, true);
1618
1619                 if (m->action_what != 0) {
1620                         usec_t x, y;
1621
1622                         x = now(CLOCK_MONOTONIC);
1623                         y = m->action_timestamp + m->inhibit_delay_max;
1624
1625                         msec = x >= y ? 0 : (int) ((y - x) / USEC_PER_MSEC);
1626                 }
1627
1628                 n = epoll_wait(m->epoll_fd, &event, 1, msec);
1629                 if (n < 0) {
1630                         if (errno == EINTR || errno == EAGAIN)
1631                                 continue;
1632
1633                         log_error("epoll() failed: %m");
1634                         return -errno;
1635                 }
1636
1637                 if (n == 0)
1638                         continue;
1639
1640                 switch (event.data.u32) {
1641
1642                 case FD_SEAT_UDEV:
1643                         manager_dispatch_seat_udev(m);
1644                         break;
1645
1646                 case FD_VCSA_UDEV:
1647                         manager_dispatch_vcsa_udev(m);
1648                         break;
1649
1650                 case FD_BUTTON_UDEV:
1651                         manager_dispatch_button_udev(m);
1652                         break;
1653
1654                 case FD_CONSOLE:
1655                         manager_dispatch_console(m);
1656                         break;
1657
1658                 case FD_IDLE_ACTION:
1659                         manager_dispatch_idle_action(m);
1660                         break;
1661
1662                 case FD_BUS:
1663                         bus_loop_dispatch(m->bus_fd);
1664                         break;
1665
1666                 default:
1667                         if (event.data.u32 >= FD_OTHER_BASE)
1668                                 manager_dispatch_other(m, event.data.u32 - FD_OTHER_BASE);
1669                 }
1670         }
1671
1672         return 0;
1673 }
1674
1675 static int manager_parse_config_file(Manager *m) {
1676         FILE *f;
1677         const char *fn;
1678         int r;
1679
1680         assert(m);
1681
1682         fn = "/etc/systemd/logind.conf";
1683         f = fopen(fn, "re");
1684         if (!f) {
1685                 if (errno == ENOENT)
1686                         return 0;
1687
1688                 log_warning("Failed to open configuration file %s: %m", fn);
1689                 return -errno;
1690         }
1691
1692         r = config_parse(fn, f, "Login\0", config_item_perf_lookup, (void*) logind_gperf_lookup, false, m);
1693         if (r < 0)
1694                 log_warning("Failed to parse configuration file: %s", strerror(-r));
1695
1696         fclose(f);
1697
1698         return r;
1699 }
1700
1701 int main(int argc, char *argv[]) {
1702         Manager *m = NULL;
1703         int r;
1704
1705         log_set_target(LOG_TARGET_AUTO);
1706         log_set_facility(LOG_AUTH);
1707         log_parse_environment();
1708         log_open();
1709
1710         umask(0022);
1711
1712         if (argc != 1) {
1713                 log_error("This program takes no arguments.");
1714                 r = -EINVAL;
1715                 goto finish;
1716         }
1717
1718         /* Always create the directories people can create inotify
1719          * watches in. Note that some applications might check for the
1720          * existence of /run/systemd/seats/ to determine whether
1721          * logind is available, so please always make sure this check
1722          * stays in. */
1723         mkdir_label("/run/systemd/seats", 0755);
1724         mkdir_label("/run/systemd/users", 0755);
1725         mkdir_label("/run/systemd/sessions", 0755);
1726
1727         m = manager_new();
1728         if (!m) {
1729                 r = log_oom();
1730                 goto finish;
1731         }
1732
1733         manager_parse_config_file(m);
1734
1735         r = manager_startup(m);
1736         if (r < 0) {
1737                 log_error("Failed to fully start up daemon: %s", strerror(-r));
1738                 goto finish;
1739         }
1740
1741         log_debug("systemd-logind running as pid %lu", (unsigned long) getpid());
1742
1743         sd_notify(false,
1744                   "READY=1\n"
1745                   "STATUS=Processing requests...");
1746
1747         r = manager_run(m);
1748
1749         log_debug("systemd-logind stopped as pid %lu", (unsigned long) getpid());
1750
1751 finish:
1752         sd_notify(false,
1753                   "STATUS=Shutting down...");
1754
1755         if (m)
1756                 manager_free(m);
1757
1758         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1759 }