src/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 "dbus-common.h"
  34 #include "dbus-loop.h"
  35
  36 enum {
  37         FD_UDEV,
  38         FD_CONSOLE,
  39         FD_BUS
  40 };
  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_fd = -1;
  52         m->epoll_fd = -1;
  53         m->n_autovts = 6;
  54
  55         m->devices = hashmap_new(string_hash_func, string_compare_func);
  56         m->seats = hashmap_new(string_hash_func, string_compare_func);
  57         m->sessions = hashmap_new(string_hash_func, string_compare_func);
  58         m->users = hashmap_new(trivial_hash_func, trivial_compare_func);
  59
  60         if (!m->devices || !m->seats || !m->sessions || !m->users) {
  61                 manager_free(m);
  62                 return NULL;
  63         }
  64
  65         m->udev = udev_new();
  66         if (!m->udev) {
  67                 manager_free(m);
  68                 return NULL;
  69         }
  70
  71         if (cg_get_user_path(&m->cgroup_path) < 0) {
  72                 manager_free(m);
  73                 return NULL;
  74         }
  75
  76         return m;
  77 }
  78
  79 void manager_free(Manager *m) {
  80         Session *session;
  81         User *u;
  82         Device *d;
  83         Seat *s;
  84
  85         assert(m);
  86
  87         while ((session = hashmap_first(m->sessions)))
  88                 session_free(session);
  89
  90         while ((u = hashmap_first(m->users)))
  91                 user_free(u);
  92
  93         while ((d = hashmap_first(m->devices)))
  94                 device_free(d);
  95
  96         while ((s = hashmap_first(m->seats)))
  97                 seat_free(s);
  98
  99         hashmap_free(m->sessions);
 100         hashmap_free(m->users);
 101         hashmap_free(m->devices);
 102         hashmap_free(m->seats);
 103
 104         if (m->console_active_fd >= 0)
 105                 close_nointr_nofail(m->console_active_fd);
 106
 107         if (m->udev_monitor)
 108                 udev_monitor_unref(m->udev_monitor);
 109
 110         if (m->udev)
 111                 udev_unref(m->udev);
 112
 113         if (m->bus) {
 114                 dbus_connection_flush(m->bus);
 115                 dbus_connection_close(m->bus);
 116                 dbus_connection_unref(m->bus);
 117         }
 118
 119         if (m->bus_fd >= 0)
 120                 close_nointr_nofail(m->bus_fd);
 121
 122         if (m->epoll_fd >= 0)
 123                 close_nointr_nofail(m->epoll_fd);
 124
 125         free(m->cgroup_path);
 126         free(m);
 127 }
 128
 129 int manager_add_device(Manager *m, const char *sysfs, Device **_device) {
 130         Device *d;
 131
 132         assert(m);
 133         assert(sysfs);
 134
 135         d = hashmap_get(m->devices, sysfs);
 136         if (d) {
 137                 if (_device)
 138                         *_device = d;
 139
 140                 return 0;
 141         }
 142
 143         d = device_new(m, sysfs);
 144         if (!d)
 145                 return -ENOMEM;
 146
 147         if (_device)
 148                 *_device = d;
 149
 150         return 0;
 151 }
 152
 153 int manager_add_seat(Manager *m, const char *id, Seat **_seat) {
 154         Seat *s;
 155
 156         assert(m);
 157         assert(id);
 158
 159         s = hashmap_get(m->seats, id);
 160         if (s) {
 161                 if (_seat)
 162                         *_seat = s;
 163
 164                 return 0;
 165         }
 166
 167         s = seat_new(m, id);
 168         if (!s)
 169                 return -ENOMEM;
 170
 171         if (_seat)
 172                 *_seat = s;
 173
 174         return 0;
 175 }
 176
 177 int manager_add_session(Manager *m, User *u, const char *id, Session **_session) {
 178         Session *s;
 179
 180         assert(m);
 181         assert(id);
 182
 183         s = hashmap_get(m->sessions, id);
 184         if (s) {
 185                 if (_session)
 186                         *_session = s;
 187
 188                 return 0;
 189         }
 190
 191         s = session_new(m, u, id);
 192         if (!s)
 193                 return -ENOMEM;
 194
 195         if (_session)
 196                 *_session = s;
 197
 198         return 0;
 199 }
 200
 201 int manager_add_user(Manager *m, uid_t uid, gid_t gid, const char *name, User **_user) {
 202         User *u;
 203         int r;
 204
 205         assert(m);
 206         assert(name);
 207
 208         u = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
 209         if (u) {
 210                 if (_user)
 211                         *_user = u;
 212
 213                 return 0;
 214         }
 215
 216         u = user_new(m, uid, gid, name);
 217         if (!u)
 218                 return -ENOMEM;
 219
 220         r = user_start(u);
 221         if (r < 0) {
 222                 user_stop(u);
 223                 user_free(u);
 224         } else {
 225                 if (_user)
 226                         *_user = u;
 227         }
 228
 229         return r;
 230 }
 231
 232 int manager_add_user_by_name(Manager *m, const char *name, User **_user) {
 233         struct passwd *p;
 234
 235         assert(m);
 236         assert(name);
 237
 238         errno = 0;
 239         p = getpwnam(name);
 240         if (!p)
 241                 return errno ? -errno : -ENOENT;
 242
 243         return manager_add_user(m, p->pw_uid, p->pw_gid, name, _user);
 244 }
 245
 246 int manager_add_user_by_uid(Manager *m, uid_t uid, User **_user) {
 247         struct passwd *p;
 248
 249         assert(m);
 250
 251         errno = 0;
 252         p = getpwuid(uid);
 253         if (!p)
 254                 return errno ? -errno : -ENOENT;
 255
 256         return manager_add_user(m, uid, p->pw_gid, p->pw_name, _user);
 257 }
 258
 259 int manager_process_device(Manager *m, struct udev_device *d) {
 260         const char *sn;
 261         Seat *seat;
 262         Device *device;
 263         int r;
 264
 265         assert(m);
 266
 267         sn = udev_device_get_property_value(d, "SEAT");
 268         if (!sn)
 269                 sn = "seat0";
 270
 271         r = manager_add_device(m, udev_device_get_syspath(d), &device);
 272         if (r < 0)
 273                 return r;
 274
 275         r = manager_add_seat(m, sn, &seat);
 276         if (r < 0)
 277                 return r;
 278
 279         device_attach(device, seat);
 280         return 0;
 281 }
 282
 283 int manager_enumerate_devices(Manager *m) {
 284         struct udev_list_entry *item = NULL, *first = NULL;
 285         struct udev_enumerate *e;
 286         int r = -ENOMEM;
 287
 288         assert(m);
 289
 290         /* Loads devices from udev and creates seats for them as
 291          * necessary */
 292
 293         e = udev_enumerate_new(m->udev);
 294         if (!e)
 295                 goto finish;
 296
 297         if (udev_enumerate_add_match_subsystem(e, "graphics") < 0)
 298                 goto finish;
 299
 300         if (udev_enumerate_add_match_tag(e, "seat") < 0)
 301                 goto finish;
 302
 303         if (udev_enumerate_scan_devices(e) < 0)
 304                 goto finish;
 305
 306         first = udev_enumerate_get_list_entry(e);
 307         udev_list_entry_foreach(item, first) {
 308                 struct udev_device *d;
 309                 int k;
 310
 311                 d = udev_device_new_from_syspath(m->udev, udev_list_entry_get_name(item));
 312                 if (!d)
 313                         goto finish;
 314
 315                 k = manager_process_device(m, d);
 316                 udev_device_unref(d);
 317
 318                 if (k < 0)
 319                         r = k;
 320         }
 321
 322 finish:
 323         if (e)
 324                 udev_enumerate_unref(e);
 325
 326         return r;
 327 }
 328
 329 int manager_enumerate_seats(Manager *m) {
 330         DIR *d;
 331         struct dirent *de;
 332         int r = 0;
 333
 334         assert(m);
 335
 336         /* This loads data about seats stored on disk, but does not
 337          * actually create any seats. Removes data of seats that no
 338          * longer exist. */
 339
 340         d = opendir("/run/systemd/seats");
 341         if (!d) {
 342                 if (errno == ENOENT)
 343                         return 0;
 344
 345                 log_error("Failed to open /run/systemd/seats: %m");
 346                 return -errno;
 347         }
 348
 349         while ((de = readdir(d))) {
 350                 Seat *s;
 351                 int k;
 352
 353                 if (!dirent_is_file(de))
 354                         continue;
 355
 356                 s = hashmap_get(m->seats, de->d_name);
 357                 if (!s) {
 358                         unlinkat(dirfd(d), de->d_name, 0);
 359                         continue;
 360                 }
 361
 362                 k = seat_load(s);
 363                 if (k < 0)
 364                         r = k;
 365         }
 366
 367         closedir(d);
 368
 369         return r;
 370 }
 371
 372 static int manager_enumerate_users_from_cgroup(Manager *m) {
 373         int r = 0;
 374         char *name;
 375         DIR *d;
 376
 377         r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, m->cgroup_path, &d);
 378         if (r < 0) {
 379                 if (r == -ENOENT)
 380                         return 0;
 381
 382                 log_error("Failed to open %s: %s", m->cgroup_path, strerror(-r));
 383                 return r;
 384         }
 385
 386         while ((r = cg_read_subgroup(d, &name)) > 0) {
 387                 User *user;
 388
 389                 r = manager_add_user_by_name(m, name, &user);
 390                 free(name);
 391
 392                 if (r < 0)
 393                         break;
 394
 395                 if (user->cgroup_path)
 396                         continue;
 397
 398                 if (asprintf(&user->cgroup_path, "%s/%s", m->cgroup_path, name) < 0) {
 399                         r = -ENOMEM;
 400                         break;
 401                 }
 402         }
 403
 404         if (d)
 405                 closedir(d);
 406
 407         return r;
 408 }
 409
 410 int manager_enumerate_users(Manager *m) {
 411         DIR *d;
 412         struct dirent *de;
 413         int r;
 414
 415         assert(m);
 416
 417         r = manager_enumerate_users_from_cgroup(m);
 418
 419         d = opendir("/run/systemd/users");
 420         if (!d) {
 421                 if (errno == ENOENT)
 422                         return 0;
 423
 424                 log_error("Failed to open /run/systemd/users: %m");
 425                 return -errno;
 426         }
 427
 428         while ((de = readdir(d))) {
 429                 unsigned long ul;
 430                 User *u;
 431                 int k;
 432
 433                 if (!dirent_is_file(de))
 434                         continue;
 435
 436                 k = safe_atolu(de->d_name, &ul);
 437                 if (k < 0) {
 438                         log_error("Failed to parse file name %s: %s", de->d_name, strerror(-k));
 439                         continue;
 440                 }
 441
 442                 u = hashmap_get(m->users, ULONG_TO_PTR(ul));
 443                 if (!u) {
 444                         unlinkat(dirfd(d), de->d_name, 0);
 445                         continue;
 446                 }
 447
 448                 k = user_load(u);
 449                 if (k < 0)
 450                         r = k;
 451         }
 452
 453         closedir(d);
 454
 455         return r;
 456 }
 457
 458 static int manager_enumerate_sessions_from_cgroup(Manager *m) {
 459         User *u;
 460         Iterator i;
 461         int r = 0;
 462
 463         HASHMAP_FOREACH(u, m->users, i) {
 464                 DIR *d;
 465                 char *name;
 466                 int k;
 467
 468                 k = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, &d);
 469                 if (k < 0) {
 470                         if (k == -ENOENT)
 471                                 continue;
 472
 473                         log_error("Failed to open %s: %s", u->cgroup_path, strerror(-k));
 474                         r = k;
 475                         continue;
 476                 }
 477
 478                 while ((k = cg_read_subgroup(d, &name)) > 0) {
 479                         Session *session;
 480
 481                         k = manager_add_session(m, u, name, &session);
 482                         free(name);
 483
 484                         if (k < 0)
 485                                 break;
 486
 487                         if (session->cgroup_path)
 488                                 continue;
 489
 490                         if (asprintf(&session->cgroup_path, "%s/%s", u->cgroup_path, name) < 0) {
 491                                 k = -ENOMEM;
 492                                 break;
 493                         }
 494                 }
 495
 496                 closedir(d);
 497
 498                 if (k < 0)
 499                         r = k;
 500         }
 501
 502         return r;
 503 }
 504
 505 int manager_enumerate_sessions(Manager *m) {
 506         DIR *d;
 507         struct dirent *de;
 508         int r = 0;
 509
 510         assert(m);
 511
 512         r = manager_enumerate_sessions_from_cgroup(m);
 513
 514         d = opendir("/run/systemd/sessions");
 515         if (!d) {
 516                 if (errno == ENOENT)
 517                         return 0;
 518
 519                 log_error("Failed to open /run/systemd/sessions: %m");
 520                 return -errno;
 521         }
 522
 523         while ((de = readdir(d))) {
 524                 struct Session *s;
 525                 int k;
 526
 527                 if (!dirent_is_file(de))
 528                         continue;
 529
 530                 s = hashmap_get(m->sessions, de->d_name);
 531                 if (!s) {
 532                         unlinkat(dirfd(d), de->d_name, 0);
 533                         continue;
 534                 }
 535
 536                 k = session_load(s);
 537                 if (k < 0)
 538                         r = k;
 539         }
 540
 541         closedir(d);
 542
 543         return r;
 544 }
 545
 546 int manager_start_linger_users(Manager *m) {
 547         DIR *d;
 548         struct dirent *de;
 549         int r = 0;
 550
 551         d = opendir("/var/lib/systemd/linger");
 552         if (!d) {
 553                 if (errno == ENOENT)
 554                         return 0;
 555
 556                 log_error("Failed to open /var/lib/systemd/linger/: %m");
 557                 return -errno;
 558         }
 559
 560         while ((de = readdir(d))) {
 561                 int k;
 562
 563                 if (!dirent_is_file(de))
 564                         continue;
 565
 566                 k = manager_add_user_by_name(m, de->d_name, NULL);
 567                 if (k < 0) {
 568                         log_notice("Couldn't add lingering user %s: %s", de->d_name, strerror(-k));
 569                         r = k;
 570                 }
 571         }
 572
 573         closedir(d);
 574
 575         return r;
 576 }
 577
 578 int manager_dispatch_udev(Manager *m) {
 579         struct udev_device *d;
 580         int r;
 581
 582         assert(m);
 583
 584         d = udev_monitor_receive_device(m->udev_monitor);
 585         if (!d)
 586                 return -ENOMEM;
 587
 588         r = manager_process_device(m, d);
 589         udev_device_unref(d);
 590
 591         return r;
 592 }
 593
 594 int manager_dispatch_console(Manager *m) {
 595         char t[64];
 596         ssize_t k;
 597         int r, vtnr;
 598
 599         assert(m);
 600
 601         lseek(m->console_active_fd, SEEK_SET, 0);
 602
 603         k = read(m->console_active_fd, t, sizeof(t)-1);
 604         if (k <= 0) {
 605                 log_error("Failed to read current console: %s", k < 0 ? strerror(-errno) : "EOF");
 606                 return k < 0 ? -errno : -EIO;
 607         }
 608
 609         t[k] = 0;
 610         if (!startswith(t, "tty")) {
 611                 log_error("Hm, /sys/class/tty/tty0/active is badly formatted.");
 612                 return -EIO;
 613         }
 614
 615         r = safe_atoi(t+3, &vtnr);
 616         if (r < 0) {
 617                 log_error("Failed to parse VT number %s", t+3);
 618                 return r;
 619         }
 620
 621         if (vtnr <= 0) {
 622                 log_error("VT number invalid: %s", t+3);
 623                 return -EIO;
 624         }
 625
 626         if (m->vtconsole)
 627                 seat_active_vt_changed(m->vtconsole, vtnr);
 628
 629         return 0;
 630 }
 631
 632 static int vt_is_busy(int vtnr) {
 633         struct vt_stat vt_stat;
 634         int r = 0, fd;
 635
 636         assert(vtnr >= 1);
 637
 638         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
 639         if (fd < 0)
 640                 return -errno;
 641
 642         if (ioctl(fd, VT_GETSTATE, &vt_stat) < 0)
 643                 r = -errno;
 644         else
 645                 r = !!(vt_stat.v_state & (1 << vtnr));
 646
 647         close_nointr_nofail(fd);
 648
 649         return r;
 650 }
 651
 652 int manager_spawn_autovt(Manager *m, int vtnr) {
 653         int r;
 654
 655         assert(m);
 656
 657         r = vt_is_busy(vtnr);
 658         if (r != 0)
 659                 return r;
 660
 661         /* ... */
 662
 663         return 0;
 664 }
 665
 666 static DBusHandlerResult login_message_handler(
 667                 DBusConnection *connection,
 668                 DBusMessage *message,
 669                 void *userdata) {
 670
 671         return DBUS_HANDLER_RESULT_HANDLED;
 672 }
 673
 674 static DBusHandlerResult login_message_filter(
 675                 DBusConnection *connection,
 676                 DBusMessage *message,
 677                 void *userdata) {
 678
 679         return DBUS_HANDLER_RESULT_HANDLED;
 680 }
 681
 682 static int manager_connect_bus(Manager *m) {
 683         const DBusObjectPathVTable login_vtable = {
 684                 .message_function = login_message_handler
 685         };
 686
 687         DBusError error;
 688         int r;
 689         struct epoll_event ev;
 690
 691         assert(m);
 692         assert(!m->bus);
 693         assert(m->bus_fd < 0);
 694
 695         dbus_error_init(&error);
 696
 697         m->bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
 698         if (!m->bus) {
 699                 log_error("Failed to get system D-Bus connection: %s", error.message);
 700                 r = -ECONNREFUSED;
 701                 goto fail;
 702         }
 703
 704         if (!dbus_connection_register_object_path(m->bus, "/org/freedesktop/login1", &login_vtable, NULL)) {
 705                 log_error("Not enough memory");
 706                 r = -ENOMEM;
 707                 goto fail;
 708         }
 709
 710         if (!dbus_connection_add_filter(m->bus, login_message_filter, m, NULL)) {
 711                 log_error("Not enough memory");
 712                 r = -ENOMEM;
 713                 goto fail;
 714         }
 715
 716         dbus_bus_add_match(m->bus,
 717                            "type='signal',"
 718                            "interface='org.freedesktop.systemd1.Agent',"
 719                            "member='Released',"
 720                            "path='/org/freedesktop/systemd1/agent'",
 721                            &error);
 722
 723         if (dbus_error_is_set(&error)) {
 724                 log_error("Failed to register match: %s", error.message);
 725                 r = -EIO;
 726                 goto fail;
 727         }
 728
 729         if (dbus_bus_request_name(m->bus, "org.freedesktop.login1", DBUS_NAME_FLAG_DO_NOT_QUEUE, &error) < 0) {
 730                 log_error("Failed to register name on bus: %s", error.message);
 731                 r = -EEXIST;
 732                 goto fail;
 733         }
 734
 735         m->bus_fd = bus_loop_open(m->bus);
 736         if (m->bus_fd < 0) {
 737                 r = m->bus_fd;
 738                 goto fail;
 739         }
 740
 741         zero(ev);
 742         ev.events = EPOLLIN;
 743         ev.data.u32 = FD_BUS;
 744
 745         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->bus_fd, &ev) < 0)
 746                 goto fail;
 747
 748         return 0;
 749
 750 fail:
 751         dbus_error_free(&error);
 752
 753         return r;
 754 }
 755
 756 static int manager_connect_console(Manager *m) {
 757         struct epoll_event ev;
 758
 759         assert(m);
 760         assert(m->console_active_fd < 0);
 761
 762         m->console_active_fd = open("/sys/class/tty/tty0/active", O_RDONLY|O_NOCTTY|O_CLOEXEC);
 763         if (m->console_active_fd < 0) {
 764                 log_error("Failed to open /sys/class/tty/tty0/active: %m");
 765                 return -errno;
 766         }
 767
 768         zero(ev);
 769         ev.events = EPOLLIN;
 770         ev.data.u32 = FD_CONSOLE;
 771
 772         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->console_active_fd, &ev) < 0)
 773                 return -errno;
 774
 775         return 0;
 776 }
 777
 778 static int manager_connect_udev(Manager *m) {
 779         struct epoll_event ev;
 780
 781         assert(m);
 782         assert(!m->udev_monitor);
 783
 784         m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
 785         if (!m->udev_monitor)
 786                 return -ENOMEM;
 787
 788         udev_monitor_filter_add_match_tag(m->udev_monitor, "seat");
 789
 790         if (udev_monitor_filter_add_match_subsystem_devtype(m->udev_monitor, "graphics", NULL) < 0)
 791                 return -ENOMEM;
 792
 793         if (udev_monitor_enable_receiving(m->udev_monitor) < 0)
 794                 return -ENOMEM;
 795
 796         m->udev_fd = udev_monitor_get_fd(m->udev_monitor);
 797
 798         zero(ev);
 799         ev.events = EPOLLIN;
 800         ev.data.u32 = FD_UDEV;
 801
 802         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_fd, &ev) < 0)
 803                 return -errno;
 804
 805         return 0;
 806 }
 807
 808 int manager_startup(Manager *m) {
 809         int r;
 810
 811         assert(m);
 812         assert(m->epoll_fd <= 0);
 813
 814         m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
 815         if (m->epoll_fd < 0)
 816                 return -errno;
 817
 818         /* Connect to udev */
 819         r = manager_connect_udev(m);
 820         if (r < 0)
 821                 return r;
 822
 823         /* Connect to console */
 824         r = manager_connect_console(m);
 825         if (r < 0)
 826                 return r;
 827
 828         /* Connect to the bus */
 829         r = manager_connect_bus(m);
 830         if (r < 0)
 831                 return r;
 832
 833         /* Deserialize state */
 834         manager_enumerate_devices(m);
 835         manager_enumerate_seats(m);
 836         manager_enumerate_users(m);
 837         manager_enumerate_sessions(m);
 838
 839         /* Spawn lingering users */
 840         manager_start_linger_users(m);
 841
 842         return 0;
 843 }
 844
 845 int manager_run(Manager *m) {
 846         assert(m);
 847
 848         for (;;) {
 849                 struct epoll_event event;
 850                 int n;
 851
 852                 if (dbus_connection_dispatch(m->bus) != DBUS_DISPATCH_COMPLETE)
 853                         continue;
 854
 855                 n = epoll_wait(m->epoll_fd, &event, 1, -1);
 856                 if (n < 0) {
 857                         log_error("epoll() failed: %m");
 858                         return -errno;
 859                 }
 860
 861                 switch (event.data.u32) {
 862
 863                 case FD_UDEV:
 864                         manager_dispatch_udev(m);
 865                         break;
 866
 867                 case FD_CONSOLE:
 868                         manager_dispatch_console(m);
 869                         break;
 870
 871                 case FD_BUS:
 872                         bus_loop_dispatch(m->bus_fd);
 873                         break;
 874                 }
 875         }
 876
 877         return 0;
 878 }
 879
 880 int main(int argc, char *argv[]) {
 881         Manager *m = NULL;
 882         int r;
 883
 884         log_set_target(LOG_TARGET_AUTO);
 885         log_parse_environment();
 886         log_open();
 887
 888         if (argc != 1) {
 889                 log_error("This program takes no arguments.");
 890                 r = -EINVAL;
 891                 goto finish;
 892         }
 893
 894         umask(0022);
 895
 896         m = manager_new();
 897         if (!m) {
 898                 log_error("Out of memory");
 899                 r = -ENOMEM;
 900                 goto finish;
 901         }
 902
 903         r = manager_startup(m);
 904         if (r < 0) {
 905                 log_error("Failed to fully start up daemon: %s", strerror(-r));
 906                 goto finish;
 907         }
 908
 909         r = manager_run(m);
 910
 911 finish:
 912         if (m)
 913                 manager_free(m);
 914
 915         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 916 }