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