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 General Public License as published by
  10   the Free Software Foundation; either version 2 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   General Public License for more details.
  17
  18   You should have received a copy of the GNU 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
  32 #include "logind.h"
  33 #include "sd-daemon.h"
  34 #include "dbus-common.h"
  35 #include "dbus-loop.h"
  36 #include "strv.h"
  37 #include "conf-parser.h"
  38
  39 Manager *manager_new(void) {
  40         Manager *m;
  41
  42         m = new0(Manager, 1);
  43         if (!m)
  44                 return NULL;
  45
  46         m->console_active_fd = -1;
  47         m->bus_fd = -1;
  48         m->udev_seat_fd = -1;
  49         m->udev_vcsa_fd = -1;
  50         m->epoll_fd = -1;
  51         m->n_autovts = 6;
  52
  53         m->devices = hashmap_new(string_hash_func, string_compare_func);
  54         m->seats = hashmap_new(string_hash_func, string_compare_func);
  55         m->sessions = hashmap_new(string_hash_func, string_compare_func);
  56         m->users = hashmap_new(trivial_hash_func, trivial_compare_func);
  57         m->cgroups = hashmap_new(string_hash_func, string_compare_func);
  58         m->fifo_fds = hashmap_new(trivial_hash_func, trivial_compare_func);
  59
  60         if (!m->devices || !m->seats || !m->sessions || !m->users || !m->cgroups || !m->fifo_fds) {
  61                 manager_free(m);
  62                 return NULL;
  63         }
  64
  65         m->reset_controllers = strv_new("cpu", NULL);
  66         m->kill_exclude_users = strv_new("root", NULL);
  67         if (!m->reset_controllers || !m->kill_exclude_users) {
  68                 manager_free(m);
  69                 return NULL;
  70         }
  71
  72         m->udev = udev_new();
  73         if (!m->udev) {
  74                 manager_free(m);
  75                 return NULL;
  76         }
  77
  78         if (cg_get_user_path(&m->cgroup_path) < 0) {
  79                 manager_free(m);
  80                 return NULL;
  81         }
  82
  83         return m;
  84 }
  85
  86 void manager_free(Manager *m) {
  87         Session *session;
  88         User *u;
  89         Device *d;
  90         Seat *s;
  91
  92         assert(m);
  93
  94         while ((session = hashmap_first(m->sessions)))
  95                 session_free(session);
  96
  97         while ((u = hashmap_first(m->users)))
  98                 user_free(u);
  99
 100         while ((d = hashmap_first(m->devices)))
 101                 device_free(d);
 102
 103         while ((s = hashmap_first(m->seats)))
 104                 seat_free(s);
 105
 106         hashmap_free(m->sessions);
 107         hashmap_free(m->users);
 108         hashmap_free(m->devices);
 109         hashmap_free(m->seats);
 110         hashmap_free(m->cgroups);
 111         hashmap_free(m->fifo_fds);
 112
 113         if (m->console_active_fd >= 0)
 114                 close_nointr_nofail(m->console_active_fd);
 115
 116         if (m->udev_seat_monitor)
 117                 udev_monitor_unref(m->udev_seat_monitor);
 118
 119         if (m->udev_vcsa_monitor)
 120                 udev_monitor_unref(m->udev_vcsa_monitor);
 121
 122         if (m->udev)
 123                 udev_unref(m->udev);
 124
 125         if (m->bus) {
 126                 dbus_connection_flush(m->bus);
 127                 dbus_connection_close(m->bus);
 128                 dbus_connection_unref(m->bus);
 129         }
 130
 131         if (m->bus_fd >= 0)
 132                 close_nointr_nofail(m->bus_fd);
 133
 134         if (m->epoll_fd >= 0)
 135                 close_nointr_nofail(m->epoll_fd);
 136
 137         strv_free(m->controllers);
 138         strv_free(m->reset_controllers);
 139         strv_free(m->kill_only_users);
 140         strv_free(m->kill_exclude_users);
 141
 142         free(m->cgroup_path);
 143         free(m);
 144 }
 145
 146 int manager_add_device(Manager *m, const char *sysfs, Device **_device) {
 147         Device *d;
 148
 149         assert(m);
 150         assert(sysfs);
 151
 152         d = hashmap_get(m->devices, sysfs);
 153         if (d) {
 154                 if (_device)
 155                         *_device = d;
 156
 157                 return 0;
 158         }
 159
 160         d = device_new(m, sysfs);
 161         if (!d)
 162                 return -ENOMEM;
 163
 164         if (_device)
 165                 *_device = d;
 166
 167         return 0;
 168 }
 169
 170 int manager_add_seat(Manager *m, const char *id, Seat **_seat) {
 171         Seat *s;
 172
 173         assert(m);
 174         assert(id);
 175
 176         s = hashmap_get(m->seats, id);
 177         if (s) {
 178                 if (_seat)
 179                         *_seat = s;
 180
 181                 return 0;
 182         }
 183
 184         s = seat_new(m, id);
 185         if (!s)
 186                 return -ENOMEM;
 187
 188         if (_seat)
 189                 *_seat = s;
 190
 191         return 0;
 192 }
 193
 194 int manager_add_session(Manager *m, User *u, const char *id, Session **_session) {
 195         Session *s;
 196
 197         assert(m);
 198         assert(id);
 199
 200         s = hashmap_get(m->sessions, id);
 201         if (s) {
 202                 if (_session)
 203                         *_session = s;
 204
 205                 return 0;
 206         }
 207
 208         s = session_new(m, u, id);
 209         if (!s)
 210                 return -ENOMEM;
 211
 212         if (_session)
 213                 *_session = s;
 214
 215         return 0;
 216 }
 217
 218 int manager_add_user(Manager *m, uid_t uid, gid_t gid, const char *name, User **_user) {
 219         User *u;
 220
 221         assert(m);
 222         assert(name);
 223
 224         u = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
 225         if (u) {
 226                 if (_user)
 227                         *_user = u;
 228
 229                 return 0;
 230         }
 231
 232         u = user_new(m, uid, gid, name);
 233         if (!u)
 234                 return -ENOMEM;
 235
 236         if (_user)
 237                 *_user = u;
 238
 239         return 0;
 240 }
 241
 242 int manager_add_user_by_name(Manager *m, const char *name, User **_user) {
 243         uid_t uid;
 244         gid_t gid;
 245         int r;
 246
 247         assert(m);
 248         assert(name);
 249
 250         r = get_user_creds(&name, &uid, &gid, NULL);
 251         if (r < 0)
 252                 return r;
 253
 254         return manager_add_user(m, uid, gid, name, _user);
 255 }
 256
 257 int manager_add_user_by_uid(Manager *m, uid_t uid, User **_user) {
 258         struct passwd *p;
 259
 260         assert(m);
 261
 262         errno = 0;
 263         p = getpwuid(uid);
 264         if (!p)
 265                 return errno ? -errno : -ENOENT;
 266
 267         return manager_add_user(m, uid, p->pw_gid, p->pw_name, _user);
 268 }
 269
 270 int manager_process_seat_device(Manager *m, struct udev_device *d) {
 271         Device *device;
 272         int r;
 273
 274         assert(m);
 275
 276         if (streq_ptr(udev_device_get_action(d), "remove")) {
 277
 278                 device = hashmap_get(m->devices, udev_device_get_syspath(d));
 279                 if (!device)
 280                         return 0;
 281
 282                 seat_add_to_gc_queue(device->seat);
 283                 device_free(device);
 284
 285         } else {
 286                 const char *sn;
 287                 Seat *seat;
 288
 289                 sn = udev_device_get_property_value(d, "ID_SEAT");
 290                 if (isempty(sn))
 291                         sn = "seat0";
 292
 293                 if (!seat_name_is_valid(sn)) {
 294                         log_warning("Device with invalid seat name %s found, ignoring.", sn);
 295                         return 0;
 296                 }
 297
 298                 r = manager_add_device(m, udev_device_get_syspath(d), &device);
 299                 if (r < 0)
 300                         return r;
 301
 302                 r = manager_add_seat(m, sn, &seat);
 303                 if (r < 0) {
 304                         if (!device->seat)
 305                                 device_free(device);
 306
 307                         return r;
 308                 }
 309
 310                 device_attach(device, seat);
 311                 seat_start(seat);
 312         }
 313
 314         return 0;
 315 }
 316
 317 int manager_enumerate_devices(Manager *m) {
 318         struct udev_list_entry *item = NULL, *first = NULL;
 319         struct udev_enumerate *e;
 320         int r;
 321
 322         assert(m);
 323
 324         /* Loads devices from udev and creates seats for them as
 325          * necessary */
 326
 327         e = udev_enumerate_new(m->udev);
 328         if (!e) {
 329                 r = -ENOMEM;
 330                 goto finish;
 331         }
 332
 333         r = udev_enumerate_add_match_subsystem(e, "graphics");
 334         if (r < 0)
 335                 goto finish;
 336
 337         r = udev_enumerate_add_match_tag(e, "seat");
 338         if (r < 0)
 339                 goto finish;
 340
 341         r = udev_enumerate_scan_devices(e);
 342         if (r < 0)
 343                 goto finish;
 344
 345         first = udev_enumerate_get_list_entry(e);
 346         udev_list_entry_foreach(item, first) {
 347                 struct udev_device *d;
 348                 int k;
 349
 350                 d = udev_device_new_from_syspath(m->udev, udev_list_entry_get_name(item));
 351                 if (!d) {
 352                         r = -ENOMEM;
 353                         goto finish;
 354                 }
 355
 356                 k = manager_process_seat_device(m, d);
 357                 udev_device_unref(d);
 358
 359                 if (k < 0)
 360                         r = k;
 361         }
 362
 363 finish:
 364         if (e)
 365                 udev_enumerate_unref(e);
 366
 367         return r;
 368 }
 369
 370 int manager_enumerate_seats(Manager *m) {
 371         DIR *d;
 372         struct dirent *de;
 373         int r = 0;
 374
 375         assert(m);
 376
 377         /* This loads data about seats stored on disk, but does not
 378          * actually create any seats. Removes data of seats that no
 379          * longer exist. */
 380
 381         d = opendir("/run/systemd/seats");
 382         if (!d) {
 383                 if (errno == ENOENT)
 384                         return 0;
 385
 386                 log_error("Failed to open /run/systemd/seats: %m");
 387                 return -errno;
 388         }
 389
 390         while ((de = readdir(d))) {
 391                 Seat *s;
 392                 int k;
 393
 394                 if (!dirent_is_file(de))
 395                         continue;
 396
 397                 s = hashmap_get(m->seats, de->d_name);
 398                 if (!s) {
 399                         unlinkat(dirfd(d), de->d_name, 0);
 400                         continue;
 401                 }
 402
 403                 k = seat_load(s);
 404                 if (k < 0)
 405                         r = k;
 406         }
 407
 408         closedir(d);
 409
 410         return r;
 411 }
 412
 413 static int manager_enumerate_users_from_cgroup(Manager *m) {
 414         int r = 0;
 415         char *name;
 416         DIR *d;
 417         int k;
 418
 419         r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, m->cgroup_path, &d);
 420         if (r < 0) {
 421                 if (r == -ENOENT)
 422                         return 0;
 423
 424                 log_error("Failed to open %s: %s", m->cgroup_path, strerror(-r));
 425                 return r;
 426         }
 427
 428         while ((k = cg_read_subgroup(d, &name)) > 0) {
 429                 User *user;
 430
 431                 k = manager_add_user_by_name(m, name, &user);
 432                 if (k < 0) {
 433                         free(name);
 434                         r = k;
 435                         continue;
 436                 }
 437
 438                 user_add_to_gc_queue(user);
 439
 440                 if (!user->cgroup_path)
 441                         if (asprintf(&user->cgroup_path, "%s/%s", m->cgroup_path, name) < 0) {
 442                                 r = -ENOMEM;
 443                                 free(name);
 444                                 break;
 445                         }
 446
 447                 free(name);
 448         }
 449
 450         if (r >= 0 && k < 0)
 451                 r = k;
 452
 453         closedir(d);
 454
 455         return r;
 456 }
 457
 458 static int manager_enumerate_linger_users(Manager *m) {
 459         DIR *d;
 460         struct dirent *de;
 461         int r = 0;
 462
 463         d = opendir("/var/lib/systemd/linger");
 464         if (!d) {
 465                 if (errno == ENOENT)
 466                         return 0;
 467
 468                 log_error("Failed to open /var/lib/systemd/linger/: %m");
 469                 return -errno;
 470         }
 471
 472         while ((de = readdir(d))) {
 473                 int k;
 474
 475                 if (!dirent_is_file(de))
 476                         continue;
 477
 478                 k = manager_add_user_by_name(m, de->d_name, NULL);
 479                 if (k < 0) {
 480                         log_notice("Couldn't add lingering user %s: %s", de->d_name, strerror(-k));
 481                         r = k;
 482                 }
 483         }
 484
 485         closedir(d);
 486
 487         return r;
 488 }
 489
 490 int manager_enumerate_users(Manager *m) {
 491         DIR *d;
 492         struct dirent *de;
 493         int r, k;
 494
 495         assert(m);
 496
 497         /* First, enumerate user cgroups */
 498         r = manager_enumerate_users_from_cgroup(m);
 499
 500         /* Second, add lingering users on top */
 501         k = manager_enumerate_linger_users(m);
 502         if (k < 0)
 503                 r = k;
 504
 505         /* Third, read in user data stored on disk */
 506         d = opendir("/run/systemd/users");
 507         if (!d) {
 508                 if (errno == ENOENT)
 509                         return 0;
 510
 511                 log_error("Failed to open /run/systemd/users: %m");
 512                 return -errno;
 513         }
 514
 515         while ((de = readdir(d))) {
 516                 uid_t uid;
 517                 User *u;
 518
 519                 if (!dirent_is_file(de))
 520                         continue;
 521
 522                 k = parse_uid(de->d_name, &uid);
 523                 if (k < 0) {
 524                         log_error("Failed to parse file name %s: %s", de->d_name, strerror(-k));
 525                         continue;
 526                 }
 527
 528                 u = hashmap_get(m->users, ULONG_TO_PTR(uid));
 529                 if (!u) {
 530                         unlinkat(dirfd(d), de->d_name, 0);
 531                         continue;
 532                 }
 533
 534                 k = user_load(u);
 535                 if (k < 0)
 536                         r = k;
 537         }
 538
 539         closedir(d);
 540
 541         return r;
 542 }
 543
 544 static int manager_enumerate_sessions_from_cgroup(Manager *m) {
 545         User *u;
 546         Iterator i;
 547         int r = 0;
 548
 549         HASHMAP_FOREACH(u, m->users, i) {
 550                 DIR *d;
 551                 char *name;
 552                 int k;
 553
 554                 if (!u->cgroup_path)
 555                         continue;
 556
 557                 k = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, &d);
 558                 if (k < 0) {
 559                         if (k == -ENOENT)
 560                                 continue;
 561
 562                         log_error("Failed to open %s: %s", u->cgroup_path, strerror(-k));
 563                         r = k;
 564                         continue;
 565                 }
 566
 567                 while ((k = cg_read_subgroup(d, &name)) > 0) {
 568                         Session *session;
 569
 570                         if (streq(name, "shared"))
 571                                 continue;
 572
 573                         k = manager_add_session(m, u, name, &session);
 574                         if (k < 0) {
 575                                 free(name);
 576                                 break;
 577                         }
 578
 579                         session_add_to_gc_queue(session);
 580
 581                         if (!session->cgroup_path)
 582                                 if (asprintf(&session->cgroup_path, "%s/%s", u->cgroup_path, name) < 0) {
 583                                         k = -ENOMEM;
 584                                         free(name);
 585                                         break;
 586                                 }
 587
 588                         free(name);
 589                 }
 590
 591                 closedir(d);
 592
 593                 if (k < 0)
 594                         r = k;
 595         }
 596
 597         return r;
 598 }
 599
 600 int manager_enumerate_sessions(Manager *m) {
 601         DIR *d;
 602         struct dirent *de;
 603         int r = 0;
 604
 605         assert(m);
 606
 607         /* First enumerate session cgroups */
 608         r = manager_enumerate_sessions_from_cgroup(m);
 609
 610         /* Second, read in session data stored on disk */
 611         d = opendir("/run/systemd/sessions");
 612         if (!d) {
 613                 if (errno == ENOENT)
 614                         return 0;
 615
 616                 log_error("Failed to open /run/systemd/sessions: %m");
 617                 return -errno;
 618         }
 619
 620         while ((de = readdir(d))) {
 621                 struct Session *s;
 622                 int k;
 623
 624                 if (!dirent_is_file(de))
 625                         continue;
 626
 627                 s = hashmap_get(m->sessions, de->d_name);
 628                 if (!s) {
 629                         unlinkat(dirfd(d), de->d_name, 0);
 630                         continue;
 631                 }
 632
 633                 k = session_load(s);
 634                 if (k < 0)
 635                         r = k;
 636         }
 637
 638         closedir(d);
 639
 640         return r;
 641 }
 642
 643 int manager_dispatch_seat_udev(Manager *m) {
 644         struct udev_device *d;
 645         int r;
 646
 647         assert(m);
 648
 649         d = udev_monitor_receive_device(m->udev_seat_monitor);
 650         if (!d)
 651                 return -ENOMEM;
 652
 653         r = manager_process_seat_device(m, d);
 654         udev_device_unref(d);
 655
 656         return r;
 657 }
 658
 659 int manager_dispatch_vcsa_udev(Manager *m) {
 660         struct udev_device *d;
 661         int r = 0;
 662         const char *name;
 663
 664         assert(m);
 665
 666         d = udev_monitor_receive_device(m->udev_vcsa_monitor);
 667         if (!d)
 668                 return -ENOMEM;
 669
 670         name = udev_device_get_sysname(d);
 671
 672         /* Whenever a VCSA device is removed try to reallocate our
 673          * VTs, to make sure our auto VTs never go away. */
 674
 675         if (name && startswith(name, "vcsa") && streq_ptr(udev_device_get_action(d), "remove"))
 676                 r = seat_preallocate_vts(m->vtconsole);
 677
 678         udev_device_unref(d);
 679
 680         return r;
 681 }
 682
 683 int manager_dispatch_console(Manager *m) {
 684         assert(m);
 685
 686         if (m->vtconsole)
 687                 seat_read_active_vt(m->vtconsole);
 688
 689         return 0;
 690 }
 691
 692 static int vt_is_busy(int vtnr) {
 693         struct vt_stat vt_stat;
 694         int r = 0, fd;
 695
 696         assert(vtnr >= 1);
 697
 698         /* We explicitly open /dev/tty1 here instead of /dev/tty0. If
 699          * we'd open the latter we'd open the foreground tty which
 700          * hence would be unconditionally busy. By opening /dev/tty1
 701          * we avoid this. Since tty1 is special and needs to be an
 702          * explicitly loaded getty or DM this is safe. */
 703
 704         fd = open_terminal("/dev/tty1", O_RDWR|O_NOCTTY|O_CLOEXEC);
 705         if (fd < 0)
 706                 return -errno;
 707
 708         if (ioctl(fd, VT_GETSTATE, &vt_stat) < 0)
 709                 r = -errno;
 710         else
 711                 r = !!(vt_stat.v_state & (1 << vtnr));
 712
 713         close_nointr_nofail(fd);
 714
 715         return r;
 716 }
 717
 718 int manager_spawn_autovt(Manager *m, int vtnr) {
 719         int r;
 720         DBusMessage *message = NULL, *reply = NULL;
 721         char *name = NULL;
 722         const char *mode = "fail";
 723         DBusError error;
 724
 725         assert(m);
 726         assert(vtnr >= 1);
 727
 728         dbus_error_init(&error);
 729
 730         if ((unsigned) vtnr > m->n_autovts)
 731                 return 0;
 732
 733         r = vt_is_busy(vtnr);
 734         if (r < 0)
 735                 return r;
 736         else if (r > 0)
 737                 return -EBUSY;
 738
 739         message = dbus_message_new_method_call("org.freedesktop.systemd1", "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "StartUnit");
 740         if (!message) {
 741                 log_error("Could not allocate message.");
 742                 r = -ENOMEM;
 743                 goto finish;
 744         }
 745
 746         if (asprintf(&name, "autovt@tty%i.service", vtnr) < 0) {
 747                 log_error("Could not allocate service name.");
 748                 r = -ENOMEM;
 749                 goto finish;
 750         }
 751
 752         if (!dbus_message_append_args(message,
 753                                       DBUS_TYPE_STRING, &name,
 754                                       DBUS_TYPE_STRING, &mode,
 755                                       DBUS_TYPE_INVALID)) {
 756                 log_error("Could not attach target and flag information to message.");
 757                 r = -ENOMEM;
 758                 goto finish;
 759         }
 760
 761         reply = dbus_connection_send_with_reply_and_block(m->bus, message, -1, &error);
 762         if (!reply) {
 763                 log_error("Failed to start unit: %s", bus_error_message(&error));
 764                 goto finish;
 765         }
 766
 767         r = 0;
 768
 769 finish:
 770         free(name);
 771
 772         if (message)
 773                 dbus_message_unref(message);
 774
 775         if (reply)
 776                 dbus_message_unref(reply);
 777
 778         dbus_error_free(&error);
 779
 780         return r;
 781 }
 782
 783 void manager_cgroup_notify_empty(Manager *m, const char *cgroup) {
 784         Session *s;
 785         char *p;
 786
 787         assert(m);
 788         assert(cgroup);
 789
 790         p = strdup(cgroup);
 791         if (!p) {
 792                 log_error("Out of memory.");
 793                 return;
 794         }
 795
 796         for (;;) {
 797                 char *e;
 798
 799                 if (isempty(p) || streq(p, "/"))
 800                         break;
 801
 802                 s = hashmap_get(m->cgroups, p);
 803                 if (s)
 804                         session_add_to_gc_queue(s);
 805
 806                 assert_se(e = strrchr(p, '/'));
 807                 *e = 0;
 808         }
 809
 810         free(p);
 811 }
 812
 813 static void manager_pipe_notify_eof(Manager *m, int fd) {
 814         Session *s;
 815
 816         assert_se(m);
 817         assert_se(fd >= 0);
 818
 819         assert_se(s = hashmap_get(m->fifo_fds, INT_TO_PTR(fd + 1)));
 820         assert(s->fifo_fd == fd);
 821         session_remove_fifo(s);
 822
 823         session_stop(s);
 824 }
 825
 826 static int manager_connect_bus(Manager *m) {
 827         DBusError error;
 828         int r;
 829         struct epoll_event ev;
 830
 831         assert(m);
 832         assert(!m->bus);
 833         assert(m->bus_fd < 0);
 834
 835         dbus_error_init(&error);
 836
 837         m->bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
 838         if (!m->bus) {
 839                 log_error("Failed to get system D-Bus connection: %s", bus_error_message(&error));
 840                 r = -ECONNREFUSED;
 841                 goto fail;
 842         }
 843
 844         if (!dbus_connection_register_object_path(m->bus, "/org/freedesktop/login1", &bus_manager_vtable, m) ||
 845             !dbus_connection_register_fallback(m->bus, "/org/freedesktop/login1/seat", &bus_seat_vtable, m) ||
 846             !dbus_connection_register_fallback(m->bus, "/org/freedesktop/login1/session", &bus_session_vtable, m) ||
 847             !dbus_connection_register_fallback(m->bus, "/org/freedesktop/login1/user", &bus_user_vtable, m) ||
 848             !dbus_connection_add_filter(m->bus, bus_message_filter, m, NULL)) {
 849                 log_error("Not enough memory");
 850                 r = -ENOMEM;
 851                 goto fail;
 852         }
 853
 854         dbus_bus_add_match(m->bus,
 855                            "type='signal',"
 856                            "interface='org.freedesktop.systemd1.Agent',"
 857                            "member='Released',"
 858                            "path='/org/freedesktop/systemd1/agent'",
 859                            &error);
 860
 861         if (dbus_error_is_set(&error)) {
 862                 log_error("Failed to register match: %s", bus_error_message(&error));
 863                 r = -EIO;
 864                 goto fail;
 865         }
 866
 867         r = dbus_bus_request_name(m->bus, "org.freedesktop.login1", DBUS_NAME_FLAG_DO_NOT_QUEUE, &error);
 868         if (dbus_error_is_set(&error)) {
 869                 log_error("Failed to register name on bus: %s", bus_error_message(&error));
 870                 r = -EIO;
 871                 goto fail;
 872         }
 873
 874         if (r != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)  {
 875                 log_error("Failed to acquire name.");
 876                 r = -EEXIST;
 877                 goto fail;
 878         }
 879
 880         m->bus_fd = bus_loop_open(m->bus);
 881         if (m->bus_fd < 0) {
 882                 r = m->bus_fd;
 883                 goto fail;
 884         }
 885
 886         zero(ev);
 887         ev.events = EPOLLIN;
 888         ev.data.u32 = FD_BUS;
 889
 890         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->bus_fd, &ev) < 0)
 891                 goto fail;
 892
 893         return 0;
 894
 895 fail:
 896         dbus_error_free(&error);
 897
 898         return r;
 899 }
 900
 901 static int manager_connect_console(Manager *m) {
 902         struct epoll_event ev;
 903
 904         assert(m);
 905         assert(m->console_active_fd < 0);
 906
 907         m->console_active_fd = open("/sys/class/tty/tty0/active", O_RDONLY|O_NOCTTY|O_CLOEXEC);
 908         if (m->console_active_fd < 0) {
 909
 910                 /* On certain architectures (S390 and Xen), /dev/tty0
 911                    does not exist, so don't fail if we can't open it.*/
 912                 if (errno == ENOENT)
 913                         return 0;
 914
 915                 log_error("Failed to open /sys/class/tty/tty0/active: %m");
 916                 return -errno;
 917         }
 918
 919         zero(ev);
 920         ev.events = 0;
 921         ev.data.u32 = FD_CONSOLE;
 922
 923         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->console_active_fd, &ev) < 0)
 924                 return -errno;
 925
 926         return 0;
 927 }
 928
 929 static int manager_connect_udev(Manager *m) {
 930         struct epoll_event ev;
 931         int r;
 932
 933         assert(m);
 934         assert(!m->udev_seat_monitor);
 935         assert(!m->udev_vcsa_monitor);
 936
 937         m->udev_seat_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
 938         if (!m->udev_seat_monitor)
 939                 return -ENOMEM;
 940
 941         r = udev_monitor_filter_add_match_tag(m->udev_seat_monitor, "seat");
 942         if (r < 0)
 943                 return r;
 944
 945         r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_seat_monitor, "graphics", NULL);
 946         if (r < 0)
 947                 return r;
 948
 949         r = udev_monitor_enable_receiving(m->udev_seat_monitor);
 950         if (r < 0)
 951                 return r;
 952
 953         m->udev_seat_fd = udev_monitor_get_fd(m->udev_seat_monitor);
 954
 955         zero(ev);
 956         ev.events = EPOLLIN;
 957         ev.data.u32 = FD_SEAT_UDEV;
 958
 959         /* Don't bother watching VCSA devices, if nobody cares */
 960         if (m->n_autovts <= 0 || m->console_active_fd < 0)
 961                 return 0;
 962
 963         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_seat_fd, &ev) < 0)
 964                 return -errno;
 965
 966         m->udev_vcsa_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
 967         if (!m->udev_vcsa_monitor)
 968                 return -ENOMEM;
 969
 970         r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_vcsa_monitor, "vc", NULL);
 971         if (r < 0)
 972                 return r;
 973
 974         r = udev_monitor_enable_receiving(m->udev_vcsa_monitor);
 975         if (r < 0)
 976                 return r;
 977
 978         m->udev_vcsa_fd = udev_monitor_get_fd(m->udev_vcsa_monitor);
 979
 980         zero(ev);
 981         ev.events = EPOLLIN;
 982         ev.data.u32 = FD_VCSA_UDEV;
 983
 984         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_vcsa_fd, &ev) < 0)
 985                 return -errno;
 986
 987         return 0;
 988 }
 989
 990 void manager_gc(Manager *m, bool drop_not_started) {
 991         Seat *seat;
 992         Session *session;
 993         User *user;
 994
 995         assert(m);
 996
 997         while ((seat = m->seat_gc_queue)) {
 998                 LIST_REMOVE(Seat, gc_queue, m->seat_gc_queue, seat);
 999                 seat->in_gc_queue = false;
1000
1001                 if (seat_check_gc(seat, drop_not_started) == 0) {
1002                         seat_stop(seat);
1003                         seat_free(seat);
1004                 }
1005         }
1006
1007         while ((session = m->session_gc_queue)) {
1008                 LIST_REMOVE(Session, gc_queue, m->session_gc_queue, session);
1009                 session->in_gc_queue = false;
1010
1011                 if (session_check_gc(session, drop_not_started) == 0) {
1012                         session_stop(session);
1013                         session_free(session);
1014                 }
1015         }
1016
1017         while ((user = m->user_gc_queue)) {
1018                 LIST_REMOVE(User, gc_queue, m->user_gc_queue, user);
1019                 user->in_gc_queue = false;
1020
1021                 if (user_check_gc(user, drop_not_started) == 0) {
1022                         user_stop(user);
1023                         user_free(user);
1024                 }
1025         }
1026 }
1027
1028 int manager_get_idle_hint(Manager *m, dual_timestamp *t) {
1029         Session *s;
1030         bool idle_hint = true;
1031         dual_timestamp ts = { 0, 0 };
1032         Iterator i;
1033
1034         assert(m);
1035
1036         HASHMAP_FOREACH(s, m->sessions, i) {
1037                 dual_timestamp k;
1038                 int ih;
1039
1040                 ih = session_get_idle_hint(s, &k);
1041                 if (ih < 0)
1042                         return ih;
1043
1044                 if (!ih) {
1045                         if (!idle_hint) {
1046                                 if (k.monotonic < ts.monotonic)
1047                                         ts = k;
1048                         } else {
1049                                 idle_hint = false;
1050                                 ts = k;
1051                         }
1052                 } else if (idle_hint) {
1053
1054                         if (k.monotonic > ts.monotonic)
1055                                 ts = k;
1056                 }
1057         }
1058
1059         if (t)
1060                 *t = ts;
1061
1062         return idle_hint;
1063 }
1064
1065 int manager_startup(Manager *m) {
1066         int r;
1067         Seat *seat;
1068         Session *session;
1069         User *user;
1070         Iterator i;
1071
1072         assert(m);
1073         assert(m->epoll_fd <= 0);
1074
1075         m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
1076         if (m->epoll_fd < 0)
1077                 return -errno;
1078
1079         /* Connect to console */
1080         r = manager_connect_console(m);
1081         if (r < 0)
1082                 return r;
1083
1084         /* Connect to udev */
1085         r = manager_connect_udev(m);
1086         if (r < 0)
1087                 return r;
1088
1089         /* Connect to the bus */
1090         r = manager_connect_bus(m);
1091         if (r < 0)
1092                 return r;
1093
1094         /* Instantiate magic seat 0 */
1095         r = manager_add_seat(m, "seat0", &m->vtconsole);
1096         if (r < 0)
1097                 return r;
1098
1099         /* Deserialize state */
1100         manager_enumerate_devices(m);
1101         manager_enumerate_seats(m);
1102         manager_enumerate_users(m);
1103         manager_enumerate_sessions(m);
1104
1105         /* Remove stale objects before we start them */
1106         manager_gc(m, false);
1107
1108         /* And start everything */
1109         HASHMAP_FOREACH(seat, m->seats, i)
1110                 seat_start(seat);
1111
1112         HASHMAP_FOREACH(user, m->users, i)
1113                 user_start(user);
1114
1115         HASHMAP_FOREACH(session, m->sessions, i)
1116                 session_start(session);
1117
1118         return 0;
1119 }
1120
1121 int manager_run(Manager *m) {
1122         assert(m);
1123
1124         for (;;) {
1125                 struct epoll_event event;
1126                 int n;
1127
1128                 manager_gc(m, true);
1129
1130                 if (dbus_connection_dispatch(m->bus) != DBUS_DISPATCH_COMPLETE)
1131                         continue;
1132
1133                 manager_gc(m, true);
1134
1135                 n = epoll_wait(m->epoll_fd, &event, 1, -1);
1136                 if (n < 0) {
1137                         if (errno == EINTR || errno == EAGAIN)
1138                                 continue;
1139
1140                         log_error("epoll() failed: %m");
1141                         return -errno;
1142                 }
1143
1144                 switch (event.data.u32) {
1145
1146                 case FD_SEAT_UDEV:
1147                         manager_dispatch_seat_udev(m);
1148                         break;
1149
1150                 case FD_VCSA_UDEV:
1151                         manager_dispatch_vcsa_udev(m);
1152                         break;
1153
1154                 case FD_CONSOLE:
1155                         manager_dispatch_console(m);
1156                         break;
1157
1158                 case FD_BUS:
1159                         bus_loop_dispatch(m->bus_fd);
1160                         break;
1161
1162                 default:
1163                         if (event.data.u32 >= FD_FIFO_BASE)
1164                                 manager_pipe_notify_eof(m, event.data.u32 - FD_FIFO_BASE);
1165                 }
1166         }
1167
1168         return 0;
1169 }
1170
1171 static int manager_parse_config_file(Manager *m) {
1172         FILE *f;
1173         const char *fn;
1174         int r;
1175
1176         assert(m);
1177
1178         fn = "/etc/systemd/systemd-logind.conf";
1179         f = fopen(fn, "re");
1180         if (!f) {
1181                 if (errno == ENOENT)
1182                         return 0;
1183
1184                 log_warning("Failed to open configuration file %s: %m", fn);
1185                 return -errno;
1186         }
1187
1188         r = config_parse(fn, f, "Login\0", config_item_perf_lookup, (void*) logind_gperf_lookup, false, m);
1189         if (r < 0)
1190                 log_warning("Failed to parse configuration file: %s", strerror(-r));
1191
1192         fclose(f);
1193
1194         return r;
1195 }
1196
1197 int main(int argc, char *argv[]) {
1198         Manager *m = NULL;
1199         int r;
1200
1201         log_set_target(LOG_TARGET_AUTO);
1202         log_parse_environment();
1203         log_open();
1204
1205         umask(0022);
1206
1207         if (argc != 1) {
1208                 log_error("This program takes no arguments.");
1209                 r = -EINVAL;
1210                 goto finish;
1211         }
1212
1213         m = manager_new();
1214         if (!m) {
1215                 log_error("Out of memory");
1216                 r = -ENOMEM;
1217                 goto finish;
1218         }
1219
1220         manager_parse_config_file(m);
1221
1222         r = manager_startup(m);
1223         if (r < 0) {
1224                 log_error("Failed to fully start up daemon: %s", strerror(-r));
1225                 goto finish;
1226         }
1227
1228         log_debug("systemd-logind running as pid %lu", (unsigned long) getpid());
1229
1230         sd_notify(false,
1231                   "READY=1\n"
1232                   "STATUS=Processing requests...");
1233
1234         r = manager_run(m);
1235
1236         log_debug("systemd-logind stopped as pid %lu", (unsigned long) getpid());
1237
1238 finish:
1239         sd_notify(false,
1240                   "STATUS=Shutting down...");
1241
1242         if (m)
1243                 manager_free(m);
1244
1245         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1246 }