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