logind: port logind to libsystemd-bus

23 files changed, 2874 insertions, 3744 deletions

diff --git a/src/libsystemd-bus/bus-util.h b/src/libsystemd-bus/bus-util.h
index b05cac11f..c4cd8dd15 100644
--- a/src/libsystemd-bus/bus-util.h
+++ b/src/libsystemd-bus/bus-util.h
@@ -109,3 +109,15 @@ DEFINE_TRIVIAL_CLEANUP_FUNC(sd_bus_message*, sd_bus_message_unref);
 #define BUS_ERROR_NO_SUCH_MACHINE "org.freedesktop.machine1.NoSuchMachine"
 #define BUS_ERROR_NO_MACHINE_FOR_PID "org.freedesktop.machine1.NoMachineForPID"
 #define BUS_ERROR_MACHINE_EXISTS "org.freedesktop.machine1.MachineExists"
+
+#define BUS_ERROR_NO_SUCH_SESSION "org.freedesktop.login1.NoSuchSession"
+#define BUS_ERROR_NO_SESSION_FOR_PID "org.freedesktop.login1.NoSessionForPID"
+#define BUS_ERROR_NO_SUCH_USER "org.freedesktop.login1.NoSuchUser"
+#define BUS_ERROR_NO_USER_FOR_PID "org.freedesktop.login1.NoUserForPID"
+#define BUS_ERROR_NO_SUCH_SEAT "org.freedesktop.login1.NoSuchSeat"
+#define BUS_ERROR_SESSION_NOT_ON_SEAT "org.freedesktop.login1.SessionNotOnSeat"
+#define BUS_ERROR_NOT_IN_CONTROL "org.freedesktop.login1.NotInControl"
+#define BUS_ERROR_DEVICE_IS_TAKEN "org.freedesktop.login1.DeviceIsTaken"
+#define BUS_ERROR_DEVICE_NOT_TAKEN "org.freedesktop.login1.DeviceNotTaken"
+#define BUS_ERROR_OPERATION_IN_PROGRESS "org.freedesktop.login1.OperationInProgress"
+#define BUS_ERROR_SLEEP_VERB_NOT_SUPPORTED "org.freedesktop.login1.SleepVerbNotSupported"
diff --git a/src/login/logind-acl.c b/src/login/logind-acl.c
index 25abcbcf8..2df2ba2c1 100644
--- a/src/login/logind-acl.c
+++ b/src/login/logind-acl.c
@@ -20,15 +20,15 @@
 ***/
 
 #include <assert.h>
-#include <sys/acl.h>
-#include <acl/libacl.h>
 #include <errno.h>
 #include <string.h>
+#include <sys/acl.h>
+#include <acl/libacl.h>
 
-#include "logind-acl.h"
 #include "util.h"
 #include "acl-util.h"
 #include "set.h"
+#include "logind-acl.h"
 
 static int flush_acl(acl_t acl) {
         acl_entry_t i;
@@ -190,9 +190,8 @@ int devnode_acl_all(struct udev *udev,
         assert(udev);
 
         nodes = set_new(string_hash_func, string_compare_func);
-        if (!nodes) {
+        if (!nodes)
                 return -ENOMEM;
-        }
 
         e = udev_enumerate_new(udev);
         if (!e) {
diff --git a/src/login/logind-action.c b/src/login/logind-action.c
index 74114ee0a..cb64df086 100644
--- a/src/login/logind-action.c
+++ b/src/login/logind-action.c
@@ -21,13 +21,13 @@
 
 #include <unistd.h>
 
-#include <systemd/sd-messages.h>
-
+#include "sd-messages.h"
 #include "conf-parser.h"
 #include "special.h"
-#include "dbus-common.h"
-#include "logind-action.h"
 #include "sleep-config.h"
+#include "bus-util.h"
+#include "bus-error.h"
+#include "logind-action.h"
 
 int manager_handle_action(
                 Manager *m,
@@ -56,24 +56,34 @@ int manager_handle_action(
                 [HANDLE_HYBRID_SLEEP] = SPECIAL_HYBRID_SLEEP_TARGET
         };
 
-        DBusError error;
-        int r;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         InhibitWhat inhibit_operation;
         bool supported;
+        int r;
 
         assert(m);
 
-        if (m->action_what) {
-                log_debug("Action already in progress, ignoring.");
-                return -EALREADY;
-        }
-
         /* If the key handling is turned off, don't do anything */
         if (handle == HANDLE_IGNORE) {
                 log_debug("Refusing operation, as it is turned off.");
                 return 0;
         }
 
+        /* If the key handling is inhibited, don't do anything */
+        if (inhibit_key > 0) {
+                if (manager_is_inhibited(m, inhibit_key, INHIBIT_BLOCK, NULL, true, false, 0)) {
+                        log_debug("Refusing operation, %s is inhibited.", inhibit_what_to_string(inhibit_key));
+                        return 0;
+                }
+        }
+
+        /* Locking is handled differently from the rest. */
+        if (handle == HANDLE_LOCK) {
+                log_info("Locking sessions...");
+                session_send_lock_all(m, true);
+                return 1;
+        }
+
         if (handle == HANDLE_SUSPEND)
                 supported = can_sleep("suspend") > 0;
         else if (handle == HANDLE_HIBERNATE)
@@ -90,19 +100,9 @@ int manager_handle_action(
                 return -ENOTSUP;
         }
 
-        /* If the key handling is inhibited, don't do anything */
-        if (inhibit_key > 0) {
-                if (manager_is_inhibited(m, inhibit_key, INHIBIT_BLOCK, NULL, true, false, 0)) {
-                        log_debug("Refusing operation, %s is inhibited.", inhibit_what_to_string(inhibit_key));
-                        return 0;
-                }
-        }
-
-        /* Locking is handled differently from the rest. */
-        if (handle == HANDLE_LOCK) {
-                log_info("Locking sessions...");
-                session_send_lock_all(m, true);
-                return 1;
+        if (m->action_what) {
+                log_debug("Action already in progress, ignoring.");
+                return -EALREADY;
         }
 
         inhibit_operation = handle == HANDLE_SUSPEND || handle == HANDLE_HIBERNATE || handle == HANDLE_HYBRID_SLEEP ? INHIBIT_SLEEP : INHIBIT_SHUTDOWN;
@@ -124,11 +124,9 @@ int manager_handle_action(
 
         log_info("%s", message_table[handle]);
 
-        dbus_error_init(&error);
         r = bus_manager_shutdown_or_sleep_now_or_later(m, target_table[handle], inhibit_operation, &error);
         if (r < 0) {
-                log_error("Failed to execute operation: %s", bus_error_message(&error));
-                dbus_error_free(&error);
+                log_error("Failed to execute operation: %s", bus_error_message(&error, r));
                 return r;
         }
 
diff --git a/src/login/logind-button.c b/src/login/logind-button.c
index ea45c28ee..7ea4e4f6a 100644
--- a/src/login/logind-button.c
+++ b/src/login/logind-button.c
@@ -26,14 +26,12 @@
 #include <sys/ioctl.h>
 #include <unistd.h>
 #include <linux/input.h>
-#include <sys/epoll.h>
 
+#include "sd-messages.h"
 #include "conf-parser.h"
 #include "util.h"
-#include "logind-button.h"
 #include "special.h"
-#include "dbus-common.h"
-#include "sd-messages.h"
+#include "logind-button.h"
 
 Button* button_new(Manager *m, const char *name) {
         Button *b;
@@ -68,10 +66,9 @@ void button_free(Button *b) {
 
         hashmap_remove(b->manager->buttons, b->name);
 
-        if (b->fd >= 0) {
-                hashmap_remove(b->manager->button_fds, INT_TO_PTR(b->fd + 1));
-                assert_se(epoll_ctl(b->manager->epoll_fd, EPOLL_CTL_DEL, b->fd, NULL) == 0);
+        sd_event_source_unref(b->event_source);
 
+        if (b->fd >= 0) {
                 /* If the device has been unplugged close() returns
                  * ENODEV, let's ignore this, hence we don't use
                  * close_nointr_nofail() */
@@ -99,62 +96,6 @@ int button_set_seat(Button *b, const char *sn) {
         return 0;
 }
 
-int button_open(Button *b) {
-        char name[256], *p;
-        struct epoll_event ev;
-        int r;
-
-        assert(b);
-
-        if (b->fd >= 0) {
-                close(b->fd);
-                b->fd = -1;
-        }
-
-        p = strappend("/dev/input/", b->name);
-        if (!p)
-                return log_oom();
-
-        b->fd = open(p, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK);
-        free(p);
-        if (b->fd < 0) {
-                log_warning("Failed to open %s: %m", b->name);
-                return -errno;
-        }
-
-        if (ioctl(b->fd, EVIOCGNAME(sizeof(name)), name) < 0) {
-                log_error("Failed to get input name: %m");
-                r = -errno;
-                goto fail;
-        }
-
-        zero(ev);
-        ev.events = EPOLLIN;
-        ev.data.u32 = FD_OTHER_BASE + b->fd;
-
-        if (epoll_ctl(b->manager->epoll_fd, EPOLL_CTL_ADD, b->fd, &ev) < 0) {
-                log_error("Failed to add to epoll: %m");
-                r = -errno;
-                goto fail;
-        }
-
-        r = hashmap_put(b->manager->button_fds, INT_TO_PTR(b->fd + 1), b);
-        if (r < 0) {
-                log_error("Failed to add to hash map: %s", strerror(-r));
-                assert_se(epoll_ctl(b->manager->epoll_fd, EPOLL_CTL_DEL, b->fd, NULL) == 0);
-                goto fail;
-        }
-
-        log_info("Watching system buttons on /dev/input/%s (%s)", b->name, name);
-
-        return 0;
-
-fail:
-        close(b->fd);
-        b->fd = -1;
-        return r;
-}
-
 static int button_handle(
                 Button *b,
                 InhibitWhat inhibit_key,
@@ -175,10 +116,13 @@ static int button_handle(
         return r;
 }
 
-int button_process(Button *b) {
+static int button_dispatch(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
+        Button *b = userdata;
         struct input_event ev;
         ssize_t l;
 
+        assert(s);
+        assert(fd == b->fd);
         assert(b);
 
         l = read(b->fd, &ev, sizeof(ev));
@@ -251,6 +195,47 @@ int button_process(Button *b) {
         return 0;
 }
 
+int button_open(Button *b) {
+        char *p, name[256];
+        int r;
+
+        assert(b);
+
+        if (b->fd >= 0) {
+                close(b->fd);
+                b->fd = -1;
+        }
+
+        p = strappenda("/dev/input/", b->name);
+
+        b->fd = open(p, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK);
+        if (b->fd < 0) {
+                log_warning("Failed to open %s: %m", b->name);
+                return -errno;
+        }
+
+        if (ioctl(b->fd, EVIOCGNAME(sizeof(name)), name) < 0) {
+                log_error("Failed to get input name: %m");
+                r = -errno;
+                goto fail;
+        }
+
+        r = sd_event_add_io(b->manager->event, b->fd, EPOLLIN, button_dispatch, b, &b->event_source);
+        if (r < 0) {
+                log_error("Failed to add button event: %s", strerror(-r));
+                goto fail;
+        }
+
+        log_info("Watching system buttons on /dev/input/%s (%s)", b->name, name);
+
+        return 0;
+
+fail:
+        close(b->fd);
+        b->fd = -1;
+        return r;
+}
+
 int button_recheck(Button *b) {
         assert(b);
 
diff --git a/src/login/logind-button.h b/src/login/logind-button.h
index 1c5a84553..83bf1fc70 100644
--- a/src/login/logind-button.h
+++ b/src/login/logind-button.h
@@ -31,6 +31,8 @@ typedef struct Button Button;
 struct Button {
         Manager *manager;
 
+        sd_event_source *event_source;
+
         char *name;
         char *seat;
         int fd;
@@ -41,7 +43,6 @@ struct Button {
 Button* button_new(Manager *m, const char *name);
 void button_free(Button*b);
 int button_open(Button *b);
-int button_process(Button *b);
 int button_recheck(Button *b);
 int button_set_seat(Button *b, const char *sn);
 
diff --git a/src/login/logind-core.c b/src/login/logind-core.c
index 36999ace4..6506f22f3 100644
--- a/src/login/logind-core.c
+++ b/src/login/logind-core.c
@@ -27,9 +27,12 @@
 #include <unistd.h>
 #include <linux/vt.h>
 
-#include "logind.h"
-#include "dbus-common.h"
 #include "strv.h"
+#include "cgroup-util.h"
+#include "audit.h"
+#include "bus-util.h"
+#include "bus-error.h"
+#include "logind.h"
 
 int manager_add_device(Manager *m, const char *sysfs, bool master, Device **_device) {
         Device *d;
@@ -213,14 +216,14 @@ int manager_watch_busname(Manager *m, const char *name) {
         assert(m);
         assert(name);
 
-        if (hashmap_get(m->busnames, name))
+        if (set_get(m->busnames, (char*) name))
                 return 0;
 
         n = strdup(name);
         if (!n)
                 return -ENOMEM;
 
-        r = hashmap_put(m->busnames, n, n);
+        r = set_put(m->busnames, n);
         if (r < 0) {
                 free(n);
                 return r;
@@ -232,22 +235,16 @@ int manager_watch_busname(Manager *m, const char *name) {
 void manager_drop_busname(Manager *m, const char *name) {
         Session *session;
         Iterator i;
-        char *key;
 
         assert(m);
         assert(name);
 
-        if (!hashmap_get(m->busnames, name))
-                return;
-
         /* keep it if the name still owns a controller */
         HASHMAP_FOREACH(session, m->sessions, i)
                 if (session_is_controller(session, name))
                         return;
 
-        key = hashmap_remove(m->busnames, name);
-        if (key)
-                free(key);
+        free(set_remove(m->busnames, (char*) name));
 }
 
 int manager_process_seat_device(Manager *m, struct udev_device *d) {
@@ -466,9 +463,9 @@ static int vt_is_busy(int vtnr) {
 }
 
 int manager_spawn_autovt(Manager *m, int vtnr) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+        _cleanup_free_ char *name = NULL;
         int r;
-        char *name = NULL;
-        const char *mode = "fail";
 
         assert(m);
         assert(vtnr >= 1);
@@ -489,26 +486,20 @@ int manager_spawn_autovt(Manager *m, int vtnr) {
                         return -EBUSY;
         }
 
-        if (asprintf(&name, "autovt@tty%i.service", vtnr) < 0) {
-                log_error("Could not allocate service name.");
-                r = -ENOMEM;
-                goto finish;
-        }
+        if (asprintf(&name, "autovt@tty%i.service", vtnr) < 0)
+                return log_oom();
 
-        r = bus_method_call_with_reply (
+        r = sd_bus_call_method(
                         m->bus,
                         "org.freedesktop.systemd1",
                         "/org/freedesktop/systemd1",
                         "org.freedesktop.systemd1.Manager",
                         "StartUnit",
+                        &error,
                         NULL,
-                        NULL,
-                        DBUS_TYPE_STRING, &name,
-                        DBUS_TYPE_STRING, &mode,
-                        DBUS_TYPE_INVALID);
-
-finish:
-        free(name);
+                        "ss", name, "fail");
+        if (r < 0)
+                log_error("Failed to start %s: %s", name, bus_error_message(&error, r));
 
         return r;
 }
diff --git a/src/login/logind-dbus.c b/src/login/logind-dbus.c
index 890c5c6b1..64716789e 100644
--- a/src/login/logind-dbus.c
+++ b/src/login/logind-dbus.c
@@ -24,429 +24,490 @@
 #include <unistd.h>
 #include <pwd.h>
 
-#include "logind.h"
-#include "dbus-common.h"
+#include "sd-id128.h"
+#include "sd-messages.h"
 #include "strv.h"
 #include "mkdir.h"
 #include "path-util.h"
-#include "polkit.h"
 #include "special.h"
 #include "sleep-config.h"
-#include "systemd/sd-id128.h"
-#include "systemd/sd-messages.h"
 #include "fileio-label.h"
 #include "label.h"
 #include "utf8.h"
 #include "unit-name.h"
-#include "bus-errors.h"
 #include "virt.h"
+#include "audit.h"
+#include "bus-util.h"
+#include "bus-error.h"
+#include "logind.h"
 
-#define BUS_MANAGER_INTERFACE                                           \
-        " <interface name=\"org.freedesktop.login1.Manager\">\n"        \
-        "  <method name=\"GetSession\">\n"                              \
-        "   <arg name=\"id\" type=\"s\" direction=\"in\"/>\n"           \
-        "   <arg name=\"session\" type=\"o\" direction=\"out\"/>\n"     \
-        "  </method>\n"                                                 \
-        "  <method name=\"GetSessionByPID\">\n"                         \
-        "   <arg name=\"pid\" type=\"u\" direction=\"in\"/>\n"          \
-        "   <arg name=\"session\" type=\"o\" direction=\"out\"/>\n"     \
-        "  </method>\n"                                                 \
-        "  <method name=\"GetUser\">\n"                                 \
-        "   <arg name=\"uid\" type=\"u\" direction=\"in\"/>\n"          \
-        "   <arg name=\"user\" type=\"o\" direction=\"out\"/>\n"        \
-        "  </method>\n"                                                 \
-        "  <method name=\"GetUserByPID\">\n"                            \
-        "   <arg name=\"pid\" type=\"u\" direction=\"in\"/>\n"          \
-        "   <arg name=\"user\" type=\"o\" direction=\"out\"/>\n"        \
-        "  </method>\n"                                                 \
-        "  <method name=\"GetSeat\">\n"                                 \
-        "   <arg name=\"id\" type=\"s\" direction=\"in\"/>\n"           \
-        "   <arg name=\"seat\" type=\"o\" direction=\"out\"/>\n"        \
-        "  </method>\n"                                                 \
-        "  <method name=\"ListSessions\">\n"                            \
-        "   <arg name=\"sessions\" type=\"a(susso)\" direction=\"out\"/>\n" \
-        "  </method>\n"                                                 \
-        "  <method name=\"ListUsers\">\n"                               \
-        "   <arg name=\"users\" type=\"a(uso)\" direction=\"out\"/>\n"  \
-        "  </method>\n"                                                 \
-        "  <method name=\"ListSeats\">\n"                               \
-        "   <arg name=\"seats\" type=\"a(so)\" direction=\"out\"/>\n"   \
-        "  </method>\n"                                                 \
-        "  <method name=\"CreateSession\">\n"                           \
-        "   <arg name=\"uid\" type=\"u\" direction=\"in\"/>\n"          \
-        "   <arg name=\"leader\" type=\"u\" direction=\"in\"/>\n"       \
-        "   <arg name=\"service\" type=\"s\" direction=\"in\"/>\n"      \
-        "   <arg name=\"type\" type=\"s\" direction=\"in\"/>\n"         \
-        "   <arg name=\"class\" type=\"s\" direction=\"in\"/>\n"        \
-        "   <arg name=\"seat\" type=\"s\" direction=\"in\"/>\n"         \
-        "   <arg name=\"vtnr\" type=\"u\" direction=\"in\"/>\n"         \
-        "   <arg name=\"tty\" type=\"s\" direction=\"in\"/>\n"          \
-        "   <arg name=\"display\" type=\"s\" direction=\"in\"/>\n"      \
-        "   <arg name=\"remote\" type=\"b\" direction=\"in\"/>\n"       \
-        "   <arg name=\"remote_user\" type=\"s\" direction=\"in\"/>\n"  \
-        "   <arg name=\"remote_host\" type=\"s\" direction=\"in\"/>\n"  \
-        "   <arg name=\"scope_properties\" type=\"a(sv)\" direction=\"in\"/>\n" \
-        "   <arg name=\"id\" type=\"s\" direction=\"out\"/>\n"          \
-        "   <arg name=\"path\" type=\"o\" direction=\"out\"/>\n"        \
-        "   <arg name=\"runtime_path\" type=\"o\" direction=\"out\"/>\n" \
-        "   <arg name=\"fd\" type=\"h\" direction=\"out\"/>\n"          \
-        "   <arg name=\"seat\" type=\"s\" direction=\"out\"/>\n"        \
-        "   <arg name=\"vtnr\" type=\"u\" direction=\"out\"/>\n"        \
-        "   <arg name=\"existing\" type=\"b\" direction=\"out\"/>\n"    \
-        "  </method>\n"                                                 \
-        "  <method name=\"ReleaseSession\">\n"                          \
-        "   <arg name=\"id\" type=\"s\" direction=\"in\"/>\n"           \
-        "  </method>\n"                                                 \
-        "  <method name=\"ActivateSession\">\n"                         \
-        "   <arg name=\"id\" type=\"s\" direction=\"in\"/>\n"           \
-        "  </method>\n"                                                 \
-        "  <method name=\"ActivateSessionOnSeat\">\n"                   \
-        "   <arg name=\"id\" type=\"s\" direction=\"in\"/>\n"           \
-        "   <arg name=\"seat\" type=\"s\" direction=\"in\"/>\n"         \
-        "  </method>\n"                                                 \
-        "  <method name=\"LockSession\">\n"                             \
-        "   <arg name=\"id\" type=\"s\" direction=\"in\"/>\n"           \
-        "  </method>\n"                                                 \
-        "  <method name=\"UnlockSession\">\n"                           \
-        "   <arg name=\"id\" type=\"s\" direction=\"in\"/>\n"           \
-        "  </method>\n"                                                 \
-        "  <method name=\"LockSessions\"/>\n"                           \
-        "  <method name=\"UnlockSessions\"/>\n"                         \
-        "  <method name=\"KillSession\">\n"                             \
-        "   <arg name=\"id\" type=\"s\" direction=\"in\"/>\n"           \
-        "   <arg name=\"who\" type=\"s\" direction=\"in\"/>\n"          \
-        "   <arg name=\"signal\" type=\"s\" direction=\"in\"/>\n"       \
-        "  </method>\n"                                                 \
-        "  <method name=\"KillUser\">\n"                                \
-        "   <arg name=\"uid\" type=\"u\" direction=\"in\"/>\n"          \
-        "   <arg name=\"signal\" type=\"s\" direction=\"in\"/>\n"       \
-        "  </method>\n"                                                 \
-        "  <method name=\"TerminateSession\">\n"                        \
-        "   <arg name=\"id\" type=\"s\" direction=\"in\"/>\n"           \
-        "  </method>\n"                                                 \
-        "  <method name=\"TerminateUser\">\n"                           \
-        "   <arg name=\"uid\" type=\"u\" direction=\"in\"/>\n"          \
-        "  </method>\n"                                                 \
-        "  <method name=\"TerminateSeat\">\n"                           \
-        "   <arg name=\"id\" type=\"s\" direction=\"in\"/>\n"           \
-        "  </method>\n"                                                 \
-        "  <method name=\"SetUserLinger\">\n"                           \
-        "   <arg name=\"uid\" type=\"u\" direction=\"in\"/>\n"          \
-        "   <arg name=\"b\" type=\"b\" direction=\"in\"/>\n"            \
-        "   <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n"  \
-        "  </method>\n"                                                 \
-        "  <method name=\"AttachDevice\">\n"                            \
-        "   <arg name=\"seat\" type=\"s\" direction=\"in\"/>\n"         \
-        "   <arg name=\"sysfs\" type=\"s\" direction=\"in\"/>\n"        \
-        "   <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n"  \
-        "  </method>\n"                                                 \
-        "  <method name=\"FlushDevices\">\n"                            \
-        "   <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n"  \
-        "  </method>\n"                                                 \
-        "  <method name=\"PowerOff\">\n"                                \
-        "   <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n"  \
-        "  </method>\n"                                                 \
-        "  <method name=\"Reboot\">\n"                                  \
-        "   <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n"  \
-        "  </method>\n"                                                 \
-        "  <method name=\"Suspend\">\n"                                 \
-        "   <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n"  \
-        "  </method>\n"                                                 \
-        "  <method name=\"Hibernate\">\n"                               \
-        "   <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n"  \
-        "  </method>\n"                                                 \
-        "  <method name=\"HybridSleep\">\n"                             \
-        "   <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n"  \
-        "  </method>\n"                                                 \
-        "  <method name=\"CanPowerOff\">\n"                             \
-        "   <arg name=\"result\" type=\"s\" direction=\"out\"/>\n"      \
-        "  </method>\n"                                                 \
-        "  <method name=\"CanReboot\">\n"                               \
-        "   <arg name=\"result\" type=\"s\" direction=\"out\"/>\n"      \
-        "  </method>\n"                                                 \
-        "  <method name=\"CanSuspend\">\n"                              \
-        "   <arg name=\"result\" type=\"s\" direction=\"out\"/>\n"      \
-        "  </method>\n"                                                 \
-        "  <method name=\"CanHibernate\">\n"                            \
-        "   <arg name=\"result\" type=\"s\" direction=\"out\"/>\n"      \
-        "  </method>\n"                                                 \
-        "  <method name=\"CanHybridSleep\">\n"                          \
-        "   <arg name=\"result\" type=\"s\" direction=\"out\"/>\n"      \
-        "  </method>\n"                                                 \
-        "  <method name=\"Inhibit\">\n"                                 \
-        "   <arg name=\"what\" type=\"s\" direction=\"in\"/>\n"         \
-        "   <arg name=\"who\" type=\"s\" direction=\"in\"/>\n"          \
-        "   <arg name=\"why\" type=\"s\" direction=\"in\"/>\n"          \
-        "   <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n"         \
-        "   <arg name=\"fd\" type=\"h\" direction=\"out\"/>\n"          \
-        "  </method>\n"                                                 \
-        "  <method name=\"ListInhibitors\">\n"                          \
-        "   <arg name=\"inhibitors\" type=\"a(ssssuu)\" direction=\"out\"/>\n" \
-        "  </method>\n"                                                 \
-        "  <signal name=\"SessionNew\">\n"                              \
-        "   <arg name=\"id\" type=\"s\"/>\n"                            \
-        "   <arg name=\"path\" type=\"o\"/>\n"                          \
-        "  </signal>\n"                                                 \
-        "  <signal name=\"SessionRemoved\">\n"                          \
-        "   <arg name=\"id\" type=\"s\"/>\n"                            \
-        "   <arg name=\"path\" type=\"o\"/>\n"                          \
-        "  </signal>\n"                                                 \
-        "  <signal name=\"UserNew\">\n"                                 \
-        "   <arg name=\"uid\" type=\"u\"/>\n"                           \
-        "   <arg name=\"path\" type=\"o\"/>\n"                          \
-        "  </signal>\n"                                                 \
-        "  <signal name=\"UserRemoved\">\n"                             \
-        "   <arg name=\"uid\" type=\"u\"/>\n"                           \
-        "   <arg name=\"path\" type=\"o\"/>\n"                          \
-        "  </signal>\n"                                                 \
-        "  <signal name=\"SeatNew\">\n"                                 \
-        "   <arg name=\"id\" type=\"s\"/>\n"                            \
-        "   <arg name=\"path\" type=\"o\"/>\n"                          \
-        "  </signal>\n"                                                 \
-        "  <signal name=\"SeatRemoved\">\n"                             \
-        "   <arg name=\"id\" type=\"s\"/>\n"                            \
-        "   <arg name=\"path\" type=\"o\"/>\n"                          \
-        "  </signal>\n"                                                 \
-        "  <signal name=\"PrepareForShutdown\">\n"                      \
-        "   <arg name=\"active\" type=\"b\"/>\n"                        \
-        "  </signal>\n"                                                 \
-        "  <signal name=\"PrepareForSleep\">\n"                         \
-        "   <arg name=\"active\" type=\"b\"/>\n"                        \
-        "  </signal>\n"                                                 \
-        "  <property name=\"NAutoVTs\" type=\"u\" access=\"read\"/>\n" \
-        "  <property name=\"KillOnlyUsers\" type=\"as\" access=\"read\"/>\n" \
-        "  <property name=\"KillExcludeUsers\" type=\"as\" access=\"read\"/>\n" \
-        "  <property name=\"KillUserProcesses\" type=\"b\" access=\"read\"/>\n" \
-        "  <property name=\"IdleHint\" type=\"b\" access=\"read\"/>\n"  \
-        "  <property name=\"IdleSinceHint\" type=\"t\" access=\"read\"/>\n" \
-        "  <property name=\"IdleSinceHintMonotonic\" type=\"t\" access=\"read\"/>\n" \
-        "  <property name=\"BlockInhibited\" type=\"s\" access=\"read\"/>\n" \
-        "  <property name=\"DelayInhibited\" type=\"s\" access=\"read\"/>\n" \
-        "  <property name=\"InhibitDelayMaxUSec\" type=\"t\" access=\"read\"/>\n" \
-        "  <property name=\"HandlePowerKey\" type=\"s\" access=\"read\"/>\n" \
-        "  <property name=\"HandleSuspendKey\" type=\"s\" access=\"read\"/>\n" \
-        "  <property name=\"HandleHibernateKey\" type=\"s\" access=\"read\"/>\n" \
-        "  <property name=\"HandleLidSwitch\" type=\"s\" access=\"read\"/>\n" \
-        "  <property name=\"IdleAction\" type=\"s\" access=\"read\"/>\n" \
-        "  <property name=\"IdleActionUSec\" type=\"t\" access=\"read\"/>\n" \
-        "  <property name=\"PreparingForShutdown\" type=\"b\" access=\"read\"/>\n" \
-        "  <property name=\"PreparingForSleep\" type=\"b\" access=\"read\"/>\n" \
-        " </interface>\n"
-
-#define INTROSPECTION_BEGIN                                             \
-        DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE                       \
-        "<node>\n"                                                      \
-        BUS_MANAGER_INTERFACE                                           \
-        BUS_PROPERTIES_INTERFACE                                        \
-        BUS_PEER_INTERFACE                                              \
-        BUS_INTROSPECTABLE_INTERFACE
-
-#define INTROSPECTION_END                                               \
-        "</node>\n"
-
-#define INTERFACES_LIST                              \
-        BUS_GENERIC_INTERFACES_LIST                  \
-        "org.freedesktop.login1.Manager\0"
-
-static int bus_manager_append_idle_hint(DBusMessageIter *i, const char *property, void *data) {
-        Manager *m = data;
-        dbus_bool_t b;
-
-        assert(i);
-        assert(property);
-        assert(m);
+static int property_get_idle_hint(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                sd_bus_error *error,
+                void *userdata) {
 
-        b = manager_get_idle_hint(m, NULL) > 0;
-        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
-                return -ENOMEM;
+        Manager *m = userdata;
 
-        return 0;
+        assert(bus);
+        assert(reply);
+        assert(m);
+
+        return sd_bus_message_append(reply, "b", manager_get_idle_hint(m, NULL) > 0);
 }
 
-static int bus_manager_append_idle_hint_since(DBusMessageIter *i, const char *property, void *data) {
-        Manager *m = data;
+static int property_get_idle_since_hint(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                sd_bus_error *error,
+                void *userdata) {
+
+        Manager *m = userdata;
         dual_timestamp t;
-        uint64_t u;
 
-        assert(i);
-        assert(property);
+        assert(bus);
+        assert(reply);
         assert(m);
 
         manager_get_idle_hint(m, &t);
-        u = streq(property, "IdleSinceHint") ? t.realtime : t.monotonic;
-
-        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, &u))
-                return -ENOMEM;
 
-        return 0;
+        return sd_bus_message_append(reply, "t", streq(property, "IdleSinceHint") ? t.realtime : t.monotonic);
 }
 
-static int bus_manager_append_inhibited(DBusMessageIter *i, const char *property, void *data) {
-        Manager *m = data;
+static int property_get_inhibited(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                sd_bus_error *error,
+                void *userdata) {
+
+        Manager *m = userdata;
         InhibitWhat w;
-        const char *p;
 
-        w = manager_inhibit_what(m, streq(property, "BlockInhibited") ? INHIBIT_BLOCK : INHIBIT_DELAY);
-        p = inhibit_what_to_string(w);
+        assert(bus);
+        assert(reply);
+        assert(m);
 
-        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &p))
-                return -ENOMEM;
+        w = manager_inhibit_what(m, streq(property, "BlockInhibited") ? INHIBIT_BLOCK : INHIBIT_DELAY);
 
-        return 0;
+        return sd_bus_message_append(reply, "s", inhibit_what_to_string(w));
 }
 
-static int bus_manager_append_preparing(DBusMessageIter *i, const char *property, void *data) {
-        Manager *m = data;
-        dbus_bool_t b;
+static int property_get_preparing(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                sd_bus_error *error,
+                void *userdata) {
 
-        assert(i);
-        assert(property);
+        Manager *m = userdata;
+        bool b;
+
+        assert(bus);
+        assert(reply);
+        assert(m);
 
         if (streq(property, "PreparingForShutdown"))
                 b = !!(m->action_what & INHIBIT_SHUTDOWN);
         else
                 b = !!(m->action_what & INHIBIT_SLEEP);
 
-        dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b);
-        return 0;
+        return sd_bus_message_append(reply, "b", b);
 }
 
-static int bus_manager_create_session(Manager *m, DBusMessage *message) {
+static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_handle_action, handle_action, HandleAction);
 
-        const char *type, *class, *cseat, *tty, *display, *remote_user, *remote_host, *service;
-        uint32_t uid, leader, audit_id = 0;
-        _cleanup_free_ char *id = NULL;
+static int method_get_session(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        _cleanup_free_ char *p = NULL;
+        Manager *m = userdata;
+        const char *name;
+        Session *session;
+        int r;
+
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        r = sd_bus_message_read(message, "s", &name);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        session = hashmap_get(m->sessions, name);
+        if (!session)
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", name);
+
+        p = session_bus_path(session);
+        if (!p)
+                return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
+
+        return sd_bus_reply_method_return(bus, message, "o", p);
+}
+
+static int method_get_session_by_pid(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        _cleanup_free_ char *p = NULL;
         Session *session = NULL;
+        Manager *m = userdata;
+        uint32_t pid;
+        int r;
+
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        r = sd_bus_message_read(message, "u", &pid);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        r = manager_get_session_by_pid(m, pid, &session);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+        if (!session)
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SESSION_FOR_PID, "PID %lu does not belong to any known session", (unsigned long) pid);
+
+        p = session_bus_path(session);
+        if (!p)
+                return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
+
+        return sd_bus_reply_method_return(bus, message, "o", p);
+}
+
+static int method_get_user(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        _cleanup_free_ char *p = NULL;
+        Manager *m = userdata;
+        uint32_t uid;
+        User *user;
+        int r;
+
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        r = sd_bus_message_read(message, "u", &uid);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        user = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
+        if (!user)
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_USER, "No user '%lu' known or logged in", (unsigned long) uid);
+
+        p = user_bus_path(user);
+        if (!p)
+                return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
+
+        return sd_bus_reply_method_return(bus, message, "o", p);
+}
+
+static int method_get_user_by_pid(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        _cleanup_free_ char *p = NULL;
+        Manager *m = userdata;
         User *user = NULL;
-        Seat *seat = NULL;
-        DBusMessageIter iter;
-        dbus_bool_t remote;
-        uint32_t vtnr = 0;
-        SessionType t;
-        SessionClass c;
-        bool b;
+        uint32_t pid;
         int r;
 
+        assert(bus);
+        assert(message);
         assert(m);
+
+        r = sd_bus_message_read(message, "u", &pid);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        r = manager_get_user_by_pid(m, pid, &user);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+        if (!user)
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_USER_FOR_PID, "PID %lu does not belong to any known or logged in user", (unsigned long) pid);
+
+        p = user_bus_path(user);
+        if (!p)
+                return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
+
+        return sd_bus_reply_method_return(bus, message, "o", p);
+}
+
+static int method_get_seat(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        _cleanup_free_ char *p = NULL;
+        Manager *m = userdata;
+        const char *name;
+        Seat *seat;
+        int r;
+
+        assert(bus);
         assert(message);
+        assert(m);
 
-        if (!dbus_message_iter_init(message, &iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32)
-                return -EINVAL;
+        r = sd_bus_message_read(message, "s", &name);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-        dbus_message_iter_get_basic(&iter, &uid);
+        seat = hashmap_get(m->seats, name);
+        if (!seat)
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SEAT, "No seat '%s' known", name);
 
-        if (!dbus_message_iter_next(&iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32)
-                return -EINVAL;
+        p = seat_bus_path(seat);
+        if (!p)
+                return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
 
-        dbus_message_iter_get_basic(&iter, &leader);
+        return sd_bus_reply_method_return(bus, message, "o", p);
+}
 
-        if (!dbus_message_iter_next(&iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
-                return -EINVAL;
+static int method_list_sessions(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        Manager *m = userdata;
+        Session *session;
+        Iterator i;
+        int r;
+
+        assert(bus);
+        assert(message);
+        assert(m);
 
-        dbus_message_iter_get_basic(&iter, &service);
+        r = sd_bus_message_new_method_return(bus, message, &reply);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-        if (!dbus_message_iter_next(&iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
-                return -EINVAL;
+        r = sd_bus_message_open_container(reply, 'a', "(susso)");
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        HASHMAP_FOREACH(session, m->sessions, i) {
+                _cleanup_free_ char *p = NULL;
+
+                p = session_bus_path(session);
+                if (!p)
+                        return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
+
+                r = sd_bus_message_append(reply, "(susso)",
+                                          session->id,
+                                          (uint32_t) session->user->uid,
+                                          session->user->name,
+                                          session->seat ? session->seat->id : "",
+                                          p);
+                if (r < 0)
+                        return sd_bus_reply_method_errno(bus, message, r, NULL);
+        }
+
+        r = sd_bus_message_close_container(reply);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        return sd_bus_send(bus, reply, NULL);
+}
+
+static int method_list_users(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        Manager *m = userdata;
+        User *user;
+        Iterator i;
+        int r;
+
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        r = sd_bus_message_new_method_return(bus, message, &reply);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        r = sd_bus_message_open_container(reply, 'a', "(uso)");
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        HASHMAP_FOREACH(user, m->users, i) {
+                _cleanup_free_ char *p = NULL;
+
+                p = user_bus_path(user);
+                if (!p)
+                        return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
+
+                r = sd_bus_message_append(reply, "(uso)",
+                                          (uint32_t) user->uid,
+                                          user->name,
+                                          p);
+                if (r < 0)
+                        return sd_bus_reply_method_errno(bus, message, r, NULL);
+        }
+
+        r = sd_bus_message_close_container(reply);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        return sd_bus_send(bus, reply, NULL);
+}
+
+static int method_list_seats(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        Manager *m = userdata;
+        Seat *seat;
+        Iterator i;
+        int r;
+
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        r = sd_bus_message_new_method_return(bus, message, &reply);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        r = sd_bus_message_open_container(reply, 'a', "(so)");
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        HASHMAP_FOREACH(seat, m->seats, i) {
+                _cleanup_free_ char *p = NULL;
+
+                p = seat_bus_path(seat);
+                if (!p)
+                        return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
+
+                r = sd_bus_message_append(reply, "so", seat->id, p);
+                if (r < 0)
+                        return sd_bus_reply_method_errno(bus, message, r, NULL);
+        }
+
+        r = sd_bus_message_close_container(reply);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        return sd_bus_send(bus, reply, NULL);
+}
+
+static int method_list_inhibitors(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        Manager *m = userdata;
+        Inhibitor *inhibitor;
+        Iterator i;
+        int r;
+
+        r = sd_bus_message_new_method_return(bus, message, &reply);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        r = sd_bus_message_open_container(reply, 'a', "(ssssuu)");
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        HASHMAP_FOREACH(inhibitor, m->inhibitors, i) {
+
+                r = sd_bus_message_append(reply, "ssssuu",
+                                          strempty(inhibit_what_to_string(inhibitor->what)),
+                                          strempty(inhibitor->who),
+                                          strempty(inhibitor->why),
+                                          strempty(inhibit_mode_to_string(inhibitor->mode)),
+                                          (uint32_t) inhibitor->uid,
+                                          (uint32_t) inhibitor->pid);
+                if (r < 0)
+                        return sd_bus_reply_method_errno(bus, message, r, NULL);
+        }
+
+        r = sd_bus_message_close_container(reply);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        return sd_bus_send(bus, reply, NULL);
+}
+
+static int method_create_session(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        const char *service, *type, *class, *cseat, *tty, *display, *remote_user, *remote_host;
+        uint32_t uid, leader, audit_id = 0;
+        _cleanup_free_ char *id = NULL;
+        Session *session = NULL;
+        Manager *m = userdata;
+        User *user = NULL;
+        Seat *seat = NULL;
+        int remote;
+        uint32_t vtnr = 0;
+        SessionType t;
+        SessionClass c;
+        int r;
+
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        r = sd_bus_message_read(message, "uussssussbss", &uid, &leader, &service, &type, &class, &cseat, &vtnr, &tty, &display, &remote, &remote_user, &remote_host);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        if (leader == 1)
+                return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid leader PID");
 
-        dbus_message_iter_get_basic(&iter, &type);
         if (isempty(type))
                 t = _SESSION_TYPE_INVALID;
         else {
                 t = session_type_from_string(type);
                 if (t < 0)
-                        return -EINVAL;
+                        return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid session type %s", type);
         }
 
-        if (!dbus_message_iter_next(&iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
-                return -EINVAL;
-
-        dbus_message_iter_get_basic(&iter, &class);
         if (isempty(class))
                 c = _SESSION_CLASS_INVALID;
         else {
                 c = session_class_from_string(class);
                 if (c < 0)
-                        return -EINVAL;
+                        return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid session class %s", class);
         }
 
-        if (!dbus_message_iter_next(&iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
-                return -EINVAL;
-
-        dbus_message_iter_get_basic(&iter, &cseat);
-
         if (isempty(cseat))
                 seat = NULL;
         else {
                 seat = hashmap_get(m->seats, cseat);
                 if (!seat)
-                        return -ENOENT;
+                        return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SEAT, "No seat '%s' known", seat);
         }
 
-        if (!dbus_message_iter_next(&iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32)
-                return -EINVAL;
-
-        dbus_message_iter_get_basic(&iter, &vtnr);
-
-        if (!dbus_message_iter_next(&iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
-                return -EINVAL;
-
-        dbus_message_iter_get_basic(&iter, &tty);
-
         if (tty_is_vc(tty)) {
                 int v;
 
                 if (!seat)
                         seat = m->seat0;
                 else if (seat != m->seat0)
-                        return -EINVAL;
+                        return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "TTY %s is virtual console but seat %s is not seat0", tty, seat);
 
                 v = vtnr_from_tty(tty);
-
                 if (v <= 0)
-                        return v < 0 ? v : -EINVAL;
+                        return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Cannot determine VT number from virtual console TTY %s", tty);
 
                 if (vtnr <= 0)
                         vtnr = (uint32_t) v;
                 else if (vtnr != (uint32_t) v)
-                        return -EINVAL;
+                        return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Specified TTY and VT number do not match");
+
         } else if (tty_is_console(tty)) {
 
                 if (!seat)
                         seat = m->seat0;
                 else if (seat != m->seat0)
-                        return -EINVAL;
+                        return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Console TTY specified but seat is not seat0");
 
                 if (vtnr != 0)
-                        return -EINVAL;
+                        return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Console TTY specified but VT number is not 0");
         }
 
         if (seat) {
                 if (seat_has_vts(seat)) {
                         if (vtnr > 63)
-                                return -EINVAL;
+                                return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "VT number out of range");
                 } else {
                         if (vtnr != 0)
-                                return -EINVAL;
+                                return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Seat has no VTs but VT number not 0");
                 }
         }
 
-        if (!dbus_message_iter_next(&iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
-                return -EINVAL;
-
-        dbus_message_iter_get_basic(&iter, &display);
-
-        if (!dbus_message_iter_next(&iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BOOLEAN)
-                return -EINVAL;
+        r = sd_bus_message_enter_container(message, 'a', "(sv)");
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
         if (t == _SESSION_TYPE_INVALID) {
                 if (!isempty(display))
@@ -464,90 +525,48 @@ static int bus_manager_create_session(Manager *m, DBusMessage *message) {
                         c = SESSION_BACKGROUND;
         }
 
-        dbus_message_iter_get_basic(&iter, &remote);
-
-        if (!dbus_message_iter_next(&iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
-                return -EINVAL;
-
-        dbus_message_iter_get_basic(&iter, &remote_user);
-
-        if (!dbus_message_iter_next(&iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
-                return -EINVAL;
-
-        dbus_message_iter_get_basic(&iter, &remote_host);
-
         if (leader <= 0) {
-                leader = bus_get_unix_process_id(m->bus, dbus_message_get_sender(message), NULL);
-                if (leader == 0)
-                        return -EINVAL;
+                assert_cc(sizeof(uint32_t) == sizeof(pid_t));
+
+                r = sd_bus_get_owner_pid(bus, sd_bus_message_get_sender(message), (pid_t*) &leader);
+                if (r < 0)
+                        return sd_bus_reply_method_errno(bus, message, r, NULL);
         }
 
         manager_get_session_by_pid(m, leader, &session);
         if (session) {
-                _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
                 _cleanup_free_ char *path = NULL;
                 _cleanup_close_ int fifo_fd = -1;
-                dbus_bool_t exists;
 
                 /* Session already exists, client is probably
                  * something like "su" which changes uid but is still
                  * the same session */
 
                 fifo_fd = session_create_fifo(session);
-                if (fifo_fd < 0) {
-                        r = fifo_fd;
-                        goto fail;
-                }
+                if (fifo_fd < 0)
+                        return sd_bus_reply_method_errno(bus, message, fifo_fd, NULL);
 
                 path = session_bus_path(session);
-                if (!path) {
-                        r = -ENOMEM;
-                        goto fail;
-                }
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply) {
-                        r = -ENOMEM;
-                        goto fail;
-                }
-
-                cseat = session->seat ? session->seat->id : "";
-                vtnr = session->vtnr;
-                exists = true;
-
-                b = dbus_message_append_args(
-                                reply,
-                                DBUS_TYPE_STRING, &session->id,
-                                DBUS_TYPE_OBJECT_PATH, &path,
-                                DBUS_TYPE_STRING, &session->user->runtime_path,
-                                DBUS_TYPE_UNIX_FD, &fifo_fd,
-                                DBUS_TYPE_STRING, &cseat,
-                                DBUS_TYPE_UINT32, &vtnr,
-                                DBUS_TYPE_BOOLEAN, &exists,
-                                DBUS_TYPE_INVALID);
-                if (!b) {
-                        r = -ENOMEM;
-                        goto fail;
-                }
-
-                if (!dbus_connection_send(m->bus, reply, NULL)) {
-                        r = -ENOMEM;
-                        goto fail;
-                }
+                if (!path)
+                        return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
 
-                return 0;
+                return sd_bus_reply_method_return(
+                                bus, message, "soshsub",
+                                session->id,
+                                path,
+                                session->user->runtime_path,
+                                fifo_fd,
+                                session->seat ? session->seat->id : "",
+                                (uint32_t) session->vtnr,
+                                true);
         }
 
         audit_session_from_pid(leader, &audit_id);
         if (audit_id > 0) {
                 /* Keep our session IDs and the audit session IDs in sync */
 
-                if (asprintf(&id, "%lu", (unsigned long) audit_id) < 0) {
-                        r = -ENOMEM;
-                        goto fail;
-                }
+                if (asprintf(&id, "%lu", (unsigned long) audit_id) < 0)
+                        return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
 
                 /* Wut? There's already a session by this name and we
                  * didn't find it above? Weird, then let's not trust
@@ -567,21 +586,23 @@ static int bus_manager_create_session(Manager *m, DBusMessage *message) {
                         free(id);
                         id = NULL;
 
-                        if (asprintf(&id, "c%lu", ++m->session_counter) < 0) {
-                                r = -ENOMEM;
-                                goto fail;
-                        }
+                        if (asprintf(&id, "c%lu", ++m->session_counter) < 0)
+                                return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
 
                 } while (hashmap_get(m->sessions, id));
         }
 
         r = manager_add_user_by_uid(m, uid, &user);
-        if (r < 0)
+        if (r < 0) {
+                r = sd_bus_reply_method_errno(bus, message, r, NULL);
                 goto fail;
+        }
 
         r = manager_add_session(m, id, &session);
-        if (r < 0)
+        if (r < 0) {
+                r = sd_bus_reply_method_errno(bus, message, r, NULL);
                 goto fail;
+        }
 
         session_set_user(session, user);
 
@@ -595,7 +616,7 @@ static int bus_manager_create_session(Manager *m, DBusMessage *message) {
         if (!isempty(tty)) {
                 session->tty = strdup(tty);
                 if (!session->tty) {
-                        r = -ENOMEM;
+                        r = sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
                         goto fail;
                 }
         }
@@ -603,7 +624,7 @@ static int bus_manager_create_session(Manager *m, DBusMessage *message) {
         if (!isempty(display)) {
                 session->display = strdup(display);
                 if (!session->display) {
-                        r = -ENOMEM;
+                        r = sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
                         goto fail;
                 }
         }
@@ -611,7 +632,7 @@ static int bus_manager_create_session(Manager *m, DBusMessage *message) {
         if (!isempty(remote_user)) {
                 session->remote_user = strdup(remote_user);
                 if (!session->remote_user) {
-                        r = -ENOMEM;
+                        r = sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
                         goto fail;
                 }
         }
@@ -619,7 +640,7 @@ static int bus_manager_create_session(Manager *m, DBusMessage *message) {
         if (!isempty(remote_host)) {
                 session->remote_host = strdup(remote_host);
                 if (!session->remote_host) {
-                        r = -ENOMEM;
+                        r = sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
                         goto fail;
                 }
         }
@@ -627,28 +648,32 @@ static int bus_manager_create_session(Manager *m, DBusMessage *message) {
         if (!isempty(service)) {
                 session->service = strdup(service);
                 if (!session->service) {
-                        r = -ENOMEM;
+                        r = sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
                         goto fail;
                 }
         }
 
         if (seat) {
                 r = seat_attach_session(seat, session);
-                if (r < 0)
+                if (r < 0) {
+                        r = sd_bus_reply_method_errno(bus, message, r, NULL);
                         goto fail;
+                }
         }
 
         r = session_start(session);
-        if (r < 0)
+        if (r < 0) {
+                r = sd_bus_reply_method_errno(bus, message, r, NULL);
                 goto fail;
+        }
 
-        session->create_message = dbus_message_ref(message);
+        session->create_message = sd_bus_message_ref(message);
 
         /* Now, let's wait until the slice unit and stuff got
          * created. We send the reply back from
          * session_send_create_reply().*/
 
-        return 0;
+        return 1;
 
 fail:
         if (session)
@@ -660,156 +685,349 @@ fail:
         return r;
 }
 
-static int bus_manager_inhibit(
-                Manager *m,
-                DBusConnection *connection,
-                DBusMessage *message,
-                DBusError *error,
-                DBusMessage **_reply) {
+static int method_release_session(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Manager *m = userdata;
+        Session *session;
+        const char *name;
+        int r;
 
-        Inhibitor *i = NULL;
-        char *id = NULL;
-        const char *who, *why, *what, *mode;
-        pid_t pid;
-        InhibitWhat w;
-        InhibitMode mm;
-        unsigned long ul;
-        int r, fifo_fd = -1;
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        r = sd_bus_message_read(message, "s", &name);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        session = hashmap_get(m->sessions, name);
+        if (!session)
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", name);
+
+        /* We use the FIFO to detect stray sessions where the process
+           invoking PAM dies abnormally. We need to make sure that
+           that process is not killed if at the clean end of the
+           session it closes the FIFO. Hence, with this call
+           explicitly turn off the FIFO logic, so that the PAM code
+           can finish clean up on its own */
+        session_remove_fifo(session);
+        session_save(session);
+        user_save(session->user);
+
+        return sd_bus_reply_method_return(bus, message, NULL);
+}
+
+static int method_activate_session(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Manager *m = userdata;
+        Session *session;
+        const char *name;
+        int r;
 
+        assert(bus);
+        assert(message);
         assert(m);
-        assert(connection);
+
+        r = sd_bus_message_read(message, "s", &name);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        session = hashmap_get(m->sessions, name);
+        if (!session)
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", name);
+
+        r = session_activate(session);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        return sd_bus_reply_method_return(bus, message, NULL);
+}
+
+static int method_activate_session_on_seat(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        const char *session_name, *seat_name;
+        Manager *m = userdata;
+        Session *session;
+        Seat *seat;
+        int r;
+
+        assert(bus);
         assert(message);
-        assert(error);
-        assert(_reply);
-
-        if (!dbus_message_get_args(
-                            message,
-                            error,
-                            DBUS_TYPE_STRING, &what,
-                            DBUS_TYPE_STRING, &who,
-                            DBUS_TYPE_STRING, &why,
-                            DBUS_TYPE_STRING, &mode,
-                            DBUS_TYPE_INVALID)) {
-                r = -EIO;
-                goto fail;
-        }
+        assert(m);
 
-        w = inhibit_what_from_string(what);
-        if (w <= 0) {
-                r = -EINVAL;
-                goto fail;
-        }
+        /* Same as ActivateSession() but refuses to work if
+         * the seat doesn't match */
 
-        mm = inhibit_mode_from_string(mode);
-        if (mm < 0) {
-                r = -EINVAL;
-                goto fail;
-        }
+        r = sd_bus_message_read(message, "ss", &session_name, &seat_name);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-        /* Delay is only supported for shutdown/sleep */
-        if (mm == INHIBIT_DELAY && (w & ~(INHIBIT_SHUTDOWN|INHIBIT_SLEEP))) {
-                r = -EINVAL;
-                goto fail;
-        }
+        session = hashmap_get(m->sessions, session_name);
+        if (!session)
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", session_name);
 
-        /* Don't allow taking delay locks while we are already
-         * executing the operation. We shouldn't create the impression
-         * that the lock was successful if the machine is about to go
-         * down/suspend any moment. */
-        if (m->action_what & w) {
-                r = -EALREADY;
-                goto fail;
-        }
+        seat = hashmap_get(m->seats, seat_name);
+        if (!seat)
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SEAT, "No seat '%s' known", seat_name);
+
+        if (session->seat != seat)
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_SESSION_NOT_ON_SEAT, "Session %s not on seat %s", session_name, seat_name);
 
-        r = verify_polkit(connection, message,
-                          w == INHIBIT_SHUTDOWN             ? (mm == INHIBIT_BLOCK ? "org.freedesktop.login1.inhibit-block-shutdown" : "org.freedesktop.login1.inhibit-delay-shutdown") :
-                          w == INHIBIT_SLEEP                ? (mm == INHIBIT_BLOCK ? "org.freedesktop.login1.inhibit-block-sleep"    : "org.freedesktop.login1.inhibit-delay-sleep") :
-                          w == INHIBIT_IDLE                 ? "org.freedesktop.login1.inhibit-block-idle" :
-                          w == INHIBIT_HANDLE_POWER_KEY     ? "org.freedesktop.login1.inhibit-handle-power-key" :
-                          w == INHIBIT_HANDLE_SUSPEND_KEY   ? "org.freedesktop.login1.inhibit-handle-suspend-key" :
-                          w == INHIBIT_HANDLE_HIBERNATE_KEY ? "org.freedesktop.login1.inhibit-handle-hibernate-key" :
-                                                              "org.freedesktop.login1.inhibit-handle-lid-switch",
-                          false, NULL, error);
+        r = session_activate(session);
         if (r < 0)
-                goto fail;
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-        ul = dbus_bus_get_unix_user(connection, dbus_message_get_sender(message), error);
-        if (ul == (unsigned long) -1) {
-                r = -EIO;
-                goto fail;
-        }
+        return sd_bus_reply_method_return(bus, message, NULL);
+}
 
-        pid = bus_get_unix_process_id(connection, dbus_message_get_sender(message), error);
-        if (pid <= 0) {
-                r = -EIO;
-                goto fail;
-        }
+static int method_lock_session(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Manager *m = userdata;
+        Session *session;
+        const char *name;
+        int r;
 
-        do {
-                free(id);
-                id = NULL;
+        assert(bus);
+        assert(message);
+        assert(m);
 
-                if (asprintf(&id, "%lu", ++m->inhibit_counter) < 0) {
-                        r = -ENOMEM;
-                        goto fail;
-                }
-        } while (hashmap_get(m->inhibitors, id));
+        r = sd_bus_message_read(message, "s", &name);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-        r = manager_add_inhibitor(m, id, &i);
-        free(id);
+        session = hashmap_get(m->sessions, name);
+        if (!session)
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", name);
 
+        r = session_send_lock(session, streq(sd_bus_message_get_member(message), "LockSession"));
         if (r < 0)
-                goto fail;
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-        i->what = w;
-        i->mode = mm;
-        i->pid = pid;
-        i->uid = (uid_t) ul;
-        i->why = strdup(why);
-        i->who = strdup(who);
+        return sd_bus_reply_method_return(bus, message, NULL);
+}
 
-        if (!i->why || !i->who) {
-                r = -ENOMEM;
-                goto fail;
-        }
+static int method_lock_sessions(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Manager *m = userdata;
+        int r;
 
-        fifo_fd = inhibitor_create_fifo(i);
-        if (fifo_fd < 0) {
-                r = fifo_fd;
-                goto fail;
-        }
+        assert(bus);
+        assert(message);
+        assert(m);
 
-        reply = dbus_message_new_method_return(message);
-        if (!reply) {
-                r = -ENOMEM;
-                goto fail;
-        }
+        r = session_send_lock_all(m, streq(sd_bus_message_get_member(message), "LockSessions"));
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-        if (!dbus_message_append_args(
-                            reply,
-                            DBUS_TYPE_UNIX_FD, &fifo_fd,
-                            DBUS_TYPE_INVALID)) {
-                r = -ENOMEM;
-                goto fail;
+        return sd_bus_reply_method_return(bus, message, NULL);
+}
+
+static int method_kill_session(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        const char *name, *swho;
+        Manager *m = userdata;
+        Session *session;
+        int32_t signo;
+        KillWho who;
+        int r;
+
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        r = sd_bus_message_read(message, "ssi", &name, &swho, &signo);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        if (isempty(swho))
+                who = KILL_ALL;
+        else {
+                who = kill_who_from_string(swho);
+                if (who < 0)
+                        return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid kill parameter '%s'", swho);
         }
 
-        close_nointr_nofail(fifo_fd);
-        *_reply = reply;
-        reply = NULL;
+        if (signo <= 0 || signo >= _NSIG)
+                return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal %i", signo);
 
-        inhibitor_start(i);
+        session = hashmap_get(m->sessions, name);
+        if (!session)
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", name);
 
-        return 0;
+        r = session_kill(session, who, signo);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-fail:
-        if (i)
-                inhibitor_free(i);
+        return sd_bus_reply_method_return(bus, message, NULL);
+}
 
-        if (fifo_fd >= 0)
-                close_nointr_nofail(fifo_fd);
+static int method_kill_user(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Manager *m = userdata;
+        uint32_t uid;
+        int32_t signo;
+        User *user;
+        int r;
 
-        return r;
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        r = sd_bus_message_read(message, "ui", &uid, &signo);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        if (signo <= 0 || signo >= _NSIG)
+                return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal %i", signo);
+
+        user = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
+        if (!user)
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_USER, "No user '%lu' known or logged in", (unsigned long) uid);
+
+        r = user_kill(user, signo);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        return sd_bus_reply_method_return(bus, message, NULL);
+}
+
+static int method_terminate_session(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Manager *m = userdata;
+        const char *name;
+        Session *session;
+        int r;
+
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        r = sd_bus_message_read(message, "s", &name);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        session = hashmap_get(m->sessions, name);
+        if (!session)
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", name);
+
+        r = session_stop(session);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        return sd_bus_reply_method_return(bus, message, NULL);
+}
+
+static int method_terminate_user(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Manager *m = userdata;
+        uint32_t uid;
+        User *user;
+        int r;
+
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        r = sd_bus_message_read(message, "u", &uid);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        user = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
+        if (!user)
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_USER, "No user '%lu' known or logged in", (unsigned long) uid);
+
+        r = user_stop(user);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        return sd_bus_reply_method_return(bus, message, NULL);
+}
+
+static int method_terminate_seat(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Manager *m = userdata;
+        const char *name;
+        Seat *seat;
+        int r;
+
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        r = sd_bus_message_read(message, "s", &name);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        seat = hashmap_get(m->seats, name);
+        if (!seat)
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SEAT, "No seat '%s' known", name);
+
+        r = seat_stop_sessions(seat);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        return sd_bus_reply_method_return(bus, message, NULL);
+}
+
+static int method_set_user_linger(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+        _cleanup_free_ char *cc = NULL;
+        Manager *m = userdata;
+        int b, r;
+        struct passwd *pw;
+        const char *path;
+        uint32_t uid;
+        int interactive;
+
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        r = sd_bus_message_read(message, "ubb", &uid, &b, &interactive);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        errno = 0;
+        pw = getpwuid(uid);
+        if (!pw)
+                return sd_bus_reply_method_errno(bus, message, errno ? errno : ENOENT, NULL);
+
+        r = bus_verify_polkit_async(bus,
+                                    &m->polkit_registry,
+                                    message,
+                                    "org.freedesktop.login1.set-user-linger",
+                                    interactive,
+                                    &error,
+                                    method_set_user_linger, m);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, &error);
+        if (r == 0)
+                return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
+
+        mkdir_p_label("/var/lib/systemd", 0755);
+
+        r = mkdir_safe_label("/var/lib/systemd/linger", 0755, 0, 0);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        cc = cescape(pw->pw_name);
+        if (!cc)
+                return sd_bus_reply_method_errno(bus, message, ENOMEM, NULL);
+
+        path = strappenda("/var/lib/systemd/linger/", cc);
+        if (b) {
+                User *u;
+
+                r = touch(path);
+                if (r < 0)
+                        return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+                if (manager_add_user_by_uid(m, uid, &u) >= 0)
+                        user_start(u);
+
+        } else {
+                User *u;
+
+                r = unlink(path);
+                if (r < 0 && errno != ENOENT)
+                        return sd_bus_reply_method_errno(bus, message, errno, NULL);
+
+                u = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
+                if (u)
+                        user_add_to_gc_queue(u);
+        }
+
+        return sd_bus_reply_method_return(bus, message, NULL);
 }
 
 static int trigger_device(Manager *m, struct udev_device *d) {
@@ -839,7 +1057,7 @@ static int trigger_device(Manager *m, struct udev_device *d) {
 
         first = udev_enumerate_get_list_entry(e);
         udev_list_entry_foreach(item, first) {
-                char *t;
+                _cleanup_free_ char *t = NULL;
                 const char *p;
 
                 p = udev_list_entry_get_name(item);
@@ -851,7 +1069,6 @@ static int trigger_device(Manager *m, struct udev_device *d) {
                 }
 
                 write_string_file(t, "change");
-                free(t);
         }
 
         r = 0;
@@ -864,9 +1081,9 @@ finish:
 }
 
 static int attach_device(Manager *m, const char *seat, const char *sysfs) {
-        struct udev_device *d;
         _cleanup_free_ char *rule = NULL, *file = NULL;
         const char *id_for_seat;
+        struct udev_device *d;
         int r;
 
         assert(m);
@@ -944,6 +1161,77 @@ static int flush_devices(Manager *m) {
         return trigger_device(m, NULL);
 }
 
+static int method_attach_device(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+        const char *sysfs, *seat;
+        Manager *m = userdata;
+        int interactive, r;
+
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        r = sd_bus_message_read(message, "ssb", &seat, &sysfs, &interactive);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        if (!path_startswith(sysfs, "/sys"))
+                return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not in /sys", sysfs);
+
+        if (!seat_name_is_valid(seat))
+                return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Seat %s is not valid", seat);
+
+        r = bus_verify_polkit_async(bus,
+                                    &m->polkit_registry,
+                                    message,
+                                    "org.freedesktop.login1.attach-device",
+                                    interactive,
+                                    &error,
+                                    method_attach_device, m);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, &error);
+        if (r == 0)
+                return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
+
+        r = attach_device(m, seat, sysfs);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        return sd_bus_reply_method_return(bus, message, NULL);
+}
+
+static int method_flush_devices(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+        Manager *m = userdata;
+        int interactive, r;
+
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        r = sd_bus_message_read(message, "b", &interactive);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        r = bus_verify_polkit_async(bus,
+                                    &m->polkit_registry,
+                                    message,
+                                    "org.freedesktop.login1.flush-devices",
+                                    interactive,
+                                    &error,
+                                    method_flush_devices, m);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, &error);
+        if (r == 0)
+                return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
+
+        r = flush_devices(m);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, &error);
+
+        return sd_bus_reply_method_return(bus, message, NULL);
+}
+
 static int have_multiple_sessions(
                 Manager *m,
                 uid_t uid) {
@@ -1003,12 +1291,12 @@ static int execute_shutdown_or_sleep(
                 Manager *m,
                 InhibitWhat w,
                 const char *unit_name,
-                DBusError *error) {
+                sd_bus_error *error) {
 
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
-        const char *mode = "replace-irreversibly", *p;
-        int r;
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        const char *p;
         char *c;
+        int r;
 
         assert(m);
         assert(w >= 0);
@@ -1017,26 +1305,21 @@ static int execute_shutdown_or_sleep(
 
         bus_manager_log_shutdown(m, w, unit_name);
 
-        r = bus_method_call_with_reply(
+        r = sd_bus_call_method(
                         m->bus,
                         "org.freedesktop.systemd1",
                         "/org/freedesktop/systemd1",
                         "org.freedesktop.systemd1.Manager",
                         "StartUnit",
-                        &reply,
                         error,
-                        DBUS_TYPE_STRING, &unit_name,
-                        DBUS_TYPE_STRING, &mode,
-                        DBUS_TYPE_INVALID);
+                        &reply,
+                        "ss", unit_name, "replace-irreversibly");
         if (r < 0)
                 return r;
 
-        if (!dbus_message_get_args(
-                            reply,
-                            error,
-                            DBUS_TYPE_OBJECT_PATH, &p,
-                            DBUS_TYPE_INVALID))
-                return -EINVAL;
+        r = sd_bus_message_read(reply, "o", &p);
+        if (r < 0)
+                return r;
 
         c = strdup(p);
         if (!c)
@@ -1067,145 +1350,33 @@ static int delay_shutdown_or_sleep(
         return 0;
 }
 
-static int bus_manager_can_shutdown_or_sleep(
-                Manager *m,
-                DBusConnection *connection,
-                DBusMessage *message,
-                InhibitWhat w,
-                const char *action,
-                const char *action_multiple_sessions,
-                const char *action_ignore_inhibit,
-                const char *sleep_verb,
-                DBusError *error,
-                DBusMessage **_reply) {
-
-        bool multiple_sessions, challenge, blocked, b;
-        const char *result = NULL;
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
-        int r;
-        unsigned long ul;
-
-        assert(m);
-        assert(connection);
-        assert(message);
-        assert(w >= 0);
-        assert(w <= _INHIBIT_WHAT_MAX);
-        assert(action);
-        assert(action_multiple_sessions);
-        assert(action_ignore_inhibit);
-        assert(error);
-        assert(_reply);
-
-        if (sleep_verb) {
-                r = can_sleep(sleep_verb);
-                if (r < 0)
-                        return r;
-                if (r == 0) {
-                        result = "na";
-                        goto finish;
-                }
-        }
-
-        ul = dbus_bus_get_unix_user(connection, dbus_message_get_sender(message), error);
-        if (ul == (unsigned long) -1)
-                return -EIO;
-
-        r = have_multiple_sessions(m, (uid_t) ul);
-        if (r < 0)
-                return r;
-
-        multiple_sessions = r > 0;
-        blocked = manager_is_inhibited(m, w, INHIBIT_BLOCK, NULL, false, true, (uid_t) ul);
-
-        if (multiple_sessions) {
-                r = verify_polkit(connection, message, action_multiple_sessions, false, &challenge, error);
-                if (r < 0)
-                        return r;
-
-                if (r > 0)
-                        result = "yes";
-                else if (challenge)
-                        result = "challenge";
-                else
-                        result = "no";
-        }
-
-        if (blocked) {
-                r = verify_polkit(connection, message, action_ignore_inhibit, false, &challenge, error);
-                if (r < 0)
-                        return r;
-
-                if (r > 0 && !result)
-                        result = "yes";
-                else if (challenge && (!result || streq(result, "yes")))
-                        result = "challenge";
-                else
-                        result = "no";
-        }
-
-        if (!multiple_sessions && !blocked) {
-                /* If neither inhibit nor multiple sessions
-                 * apply then just check the normal policy */
-
-                r = verify_polkit(connection, message, action, false, &challenge, error);
-                if (r < 0)
-                        return r;
-
-                if (r > 0)
-                        result = "yes";
-                else if (challenge)
-                        result = "challenge";
-                else
-                        result = "no";
-        }
-
-finish:
-        reply = dbus_message_new_method_return(message);
-        if (!reply)
-                return -ENOMEM;
-
-        b = dbus_message_append_args(
-                        reply,
-                        DBUS_TYPE_STRING, &result,
-                        DBUS_TYPE_INVALID);
-        if (!b)
-                return -ENOMEM;
-
-        *_reply = reply;
-        reply = NULL;
-        return 0;
-}
-
 static int send_prepare_for(Manager *m, InhibitWhat w, bool _active) {
+
         static const char * const signal_name[_INHIBIT_WHAT_MAX] = {
                 [INHIBIT_SHUTDOWN] = "PrepareForShutdown",
                 [INHIBIT_SLEEP] = "PrepareForSleep"
         };
 
-        dbus_bool_t active = _active;
-        _cleanup_dbus_message_unref_ DBusMessage *message = NULL;
+        int active = _active;
 
         assert(m);
         assert(w >= 0);
         assert(w < _INHIBIT_WHAT_MAX);
         assert(signal_name[w]);
 
-        message = dbus_message_new_signal("/org/freedesktop/login1", "org.freedesktop.login1.Manager", signal_name[w]);
-        if (!message)
-                return -ENOMEM;
-
-        if (!dbus_message_append_args(message, DBUS_TYPE_BOOLEAN, &active, DBUS_TYPE_INVALID) ||
-            !dbus_connection_send(m->bus, message, NULL))
-                return -ENOMEM;
-
-        return 0;
+        return sd_bus_emit_signal(m->bus,
+                                  "/org/freedesktop/login1",
+                                  "org.freedesktop.login1.Manager",
+                                  signal_name[w],
+                                  "b",
+                                  &active);
 }
 
 int bus_manager_shutdown_or_sleep_now_or_later(
                 Manager *m,
                 const char *unit_name,
                 InhibitWhat w,
-                DBusError *error) {
+                sd_bus_error *error) {
 
         bool delayed;
         int r;
@@ -1235,27 +1406,23 @@ int bus_manager_shutdown_or_sleep_now_or_later(
         return r;
 }
 
-static int bus_manager_do_shutdown_or_sleep(
+static int method_do_shutdown_or_sleep(
                 Manager *m,
-                DBusConnection *connection,
-                DBusMessage *message,
+                sd_bus_message *message,
                 const char *unit_name,
                 InhibitWhat w,
                 const char *action,
                 const char *action_multiple_sessions,
                 const char *action_ignore_inhibit,
                 const char *sleep_verb,
-                DBusError *error,
-                DBusMessage **_reply) {
+                sd_bus_message_handler_t method) {
 
-        dbus_bool_t interactive;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         bool multiple_sessions, blocked;
-        DBusMessage *reply = NULL;
-        int r;
-        unsigned long ul;
+        int interactive, r;
+        uid_t uid;
 
         assert(m);
-        assert(connection);
         assert(message);
         assert(unit_name);
         assert(w >= 0);
@@ -1263,1254 +1430,664 @@ static int bus_manager_do_shutdown_or_sleep(
         assert(action);
         assert(action_multiple_sessions);
         assert(action_ignore_inhibit);
-        assert(error);
-        assert(_reply);
+        assert(method);
+
+        r = sd_bus_message_read(message, "b", &interactive);
+        if (r < 0)
+                return sd_bus_reply_method_errno(m->bus, message, r, NULL);
 
         /* Don't allow multiple jobs being executed at the same time */
         if (m->action_what)
-                return -EALREADY;
-
-        if (!dbus_message_get_args(
-                            message,
-                            error,
-                            DBUS_TYPE_BOOLEAN, &interactive,
-                            DBUS_TYPE_INVALID))
-                return -EINVAL;
+                return sd_bus_reply_method_errorf(m->bus, message, BUS_ERROR_OPERATION_IN_PROGRESS, "There's already a shutdown or sleep operation in progress");
 
         if (sleep_verb) {
                 r = can_sleep(sleep_verb);
                 if (r < 0)
-                        return r;
+                        return sd_bus_reply_method_errno(m->bus, message, r, NULL);
 
                 if (r == 0)
-                        return -ENOTSUP;
+                        return sd_bus_reply_method_errorf(m->bus, message, BUS_ERROR_SLEEP_VERB_NOT_SUPPORTED, "Sleep verb not supported");
         }
 
-        ul = dbus_bus_get_unix_user(connection, dbus_message_get_sender(message), error);
-        if (ul == (unsigned long) -1)
-                return -EIO;
+        r = sd_bus_get_owner_uid(m->bus, sd_bus_message_get_sender(message), &uid);
+        if (r < 0)
+                return sd_bus_reply_method_errno(m->bus, message, r, NULL);
 
-        r = have_multiple_sessions(m, (uid_t) ul);
+        r = have_multiple_sessions(m, uid);
         if (r < 0)
-                return r;
+                return sd_bus_reply_method_errno(m->bus, message, r, NULL);
 
         multiple_sessions = r > 0;
-        blocked = manager_is_inhibited(m, w, INHIBIT_BLOCK, NULL, false, true, (uid_t) ul);
+        blocked = manager_is_inhibited(m, w, INHIBIT_BLOCK, NULL, false, true, uid);
 
         if (multiple_sessions) {
-                r = verify_polkit(connection, message, action_multiple_sessions, interactive, NULL, error);
+                r = bus_verify_polkit_async(m->bus, &m->polkit_registry, message,
+                                            action_multiple_sessions, interactive, &error, method, m);
                 if (r < 0)
-                        return r;
+                        return sd_bus_reply_method_errno(m->bus, message, r, &error);
         }
 
         if (blocked) {
-                r = verify_polkit(connection, message, action_ignore_inhibit, interactive, NULL, error);
+                r = bus_verify_polkit_async(m->bus, &m->polkit_registry, message,
+                                            action_ignore_inhibit, interactive, &error, method, m);
                 if (r < 0)
-                        return r;
+                        return sd_bus_reply_method_errno(m->bus, message, r, &error);
         }
 
         if (!multiple_sessions && !blocked) {
-                r = verify_polkit(connection, message, action, interactive, NULL, error);
+                r = bus_verify_polkit_async(m->bus, &m->polkit_registry, message,
+                                            action, interactive, &error, method, m);
                 if (r < 0)
-                        return r;
+                        return sd_bus_reply_method_errno(m->bus, message, r, &error);
         }
 
-        r = bus_manager_shutdown_or_sleep_now_or_later(m, unit_name, w, error);
+        r = bus_manager_shutdown_or_sleep_now_or_later(m, unit_name, w, &error);
         if (r < 0)
-                return r;
+                return sd_bus_reply_method_errno(m->bus, message, r, &error);
 
-        reply = dbus_message_new_method_return(message);
-        if (!reply)
-                return -ENOMEM;
-
-        *_reply = reply;
-        return 0;
+        return sd_bus_reply_method_return(m->bus, message, NULL);
 }
 
-static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_manager_append_handle_action, handle_action, HandleAction);
-
-static const BusProperty bus_login_manager_properties[] = {
-        { "NAutoVTs",               bus_property_append_unsigned,       "u",  offsetof(Manager, n_autovts)           },
-        { "KillOnlyUsers",          bus_property_append_strv,           "as", offsetof(Manager, kill_only_users),    true },
-        { "KillExcludeUsers",       bus_property_append_strv,           "as", offsetof(Manager, kill_exclude_users), true },
-        { "KillUserProcesses",      bus_property_append_bool,           "b",  offsetof(Manager, kill_user_processes) },
-        { "IdleHint",               bus_manager_append_idle_hint,       "b",  0 },
-        { "IdleSinceHint",          bus_manager_append_idle_hint_since, "t",  0 },
-        { "IdleSinceHintMonotonic", bus_manager_append_idle_hint_since, "t",  0 },
-        { "BlockInhibited",         bus_manager_append_inhibited,       "s",  0 },
-        { "DelayInhibited",         bus_manager_append_inhibited,       "s",  0 },
-        { "InhibitDelayMaxUSec",    bus_property_append_usec,           "t",  offsetof(Manager, inhibit_delay_max)   },
-        { "HandlePowerKey",         bus_manager_append_handle_action,   "s",  offsetof(Manager, handle_power_key)    },
-        { "HandleSuspendKey",       bus_manager_append_handle_action,   "s",  offsetof(Manager, handle_suspend_key)  },
-        { "HandleHibernateKey",     bus_manager_append_handle_action,   "s",  offsetof(Manager, handle_hibernate_key)},
-        { "HandleLidSwitch",        bus_manager_append_handle_action,   "s",  offsetof(Manager, handle_lid_switch)   },
-        { "IdleAction",             bus_manager_append_handle_action,   "s",  offsetof(Manager, idle_action)         },
-        { "IdleActionUSec",         bus_property_append_usec,           "t",  offsetof(Manager, idle_action_usec) },
-        { "PreparingForShutdown",   bus_manager_append_preparing,       "b",  0 },
-        { "PreparingForSleep",      bus_manager_append_preparing,       "b",  0 },
-        { NULL, }
-};
-
-static DBusHandlerResult manager_message_handler(
-                DBusConnection *connection,
-                DBusMessage *message,
-                void *userdata) {
-
+static int method_poweroff(sd_bus *bus, sd_bus_message *message, void *userdata) {
         Manager *m = userdata;
 
-        DBusError error;
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
-        int r;
-
-        assert(connection);
-        assert(message);
-        assert(m);
-
-        dbus_error_init(&error);
-
-        if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "GetSession")) {
-                const char *name;
-                char *p;
-                Session *session;
-                bool b;
-
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_STRING, &name,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
-
-                session = hashmap_get(m->sessions, name);
-                if (!session)
-                        return bus_send_error_reply(connection, message, &error, -ENOENT);
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
-
-                p = session_bus_path(session);
-                if (!p)
-                        goto oom;
-
-                b = dbus_message_append_args(
-                                reply,
-                                DBUS_TYPE_OBJECT_PATH, &p,
-                                DBUS_TYPE_INVALID);
-                free(p);
-
-                if (!b)
-                        goto oom;
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "GetSessionByPID")) {
-                uint32_t pid;
-                char *p;
-                Session *session;
-                bool b;
-
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_UINT32, &pid,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
-
-                r = manager_get_session_by_pid(m, pid, &session);
-                if (r <= 0)
-                        return bus_send_error_reply(connection, message, NULL, r < 0 ? r : -ENOENT);
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
-
-                p = session_bus_path(session);
-                if (!p)
-                        goto oom;
-
-                b = dbus_message_append_args(
-                                reply,
-                                DBUS_TYPE_OBJECT_PATH, &p,
-                                DBUS_TYPE_INVALID);
-                free(p);
-
-                if (!b)
-                        goto oom;
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "GetUser")) {
-                uint32_t uid;
-                char *p;
-                User *user;
-                bool b;
-
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_UINT32, &uid,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
-
-                user = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
-                if (!user)
-                        return bus_send_error_reply(connection, message, &error, -ENOENT);
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
-
-                p = user_bus_path(user);
-                if (!p)
-                        goto oom;
-
-                b = dbus_message_append_args(
-                                reply,
-                                DBUS_TYPE_OBJECT_PATH, &p,
-                                DBUS_TYPE_INVALID);
-                free(p);
-
-                if (!b)
-                        goto oom;
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "GetUserByPID")) {
-                uint32_t pid;
-                char *p;
-                User *user;
-                bool b;
-
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_UINT32, &pid,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
-
-                r = manager_get_user_by_pid(m, pid, &user);
-                if (r <= 0)
-                        return bus_send_error_reply(connection, message, NULL, r < 0 ? r : -ENOENT);
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
-
-                p = user_bus_path(user);
-                if (!p)
-                        goto oom;
-
-                b = dbus_message_append_args(
-                                reply,
-                                DBUS_TYPE_OBJECT_PATH, &p,
-                                DBUS_TYPE_INVALID);
-                free(p);
-
-                if (!b)
-                        goto oom;
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "GetSeat")) {
-                const char *name;
-                char *p;
-                Seat *seat;
-                bool b;
-
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_STRING, &name,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
-
-                seat = hashmap_get(m->seats, name);
-                if (!seat)
-                        return bus_send_error_reply(connection, message, &error, -ENOENT);
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
-
-                p = seat_bus_path(seat);
-                if (!p)
-                        goto oom;
-
-                b = dbus_message_append_args(
-                                reply,
-                                DBUS_TYPE_OBJECT_PATH, &p,
-                                DBUS_TYPE_INVALID);
-                free(p);
-
-                if (!b)
-                        goto oom;
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ListSessions")) {
-                char *p;
-                Session *session;
-                Iterator i;
-                DBusMessageIter iter, sub;
-                const char *empty = "";
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
-
-                dbus_message_iter_init_append(reply, &iter);
-
-                if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(susso)", &sub))
-                        goto oom;
-
-                HASHMAP_FOREACH(session, m->sessions, i) {
-                        DBusMessageIter sub2;
-                        uint32_t uid;
-
-                        if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
-                                goto oom;
-
-                        uid = session->user->uid;
-
-                        p = session_bus_path(session);
-                        if (!p)
-                                goto oom;
-
-                        if (!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &session->id) ||
-                            !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT32, &uid) ||
-                            !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &session->user->name) ||
-                            !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, session->seat ? (const char**) &session->seat->id : &empty) ||
-                            !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_OBJECT_PATH, &p)) {
-                                free(p);
-                                goto oom;
-                        }
-
-                        free(p);
-
-                        if (!dbus_message_iter_close_container(&sub, &sub2))
-                                goto oom;
-                }
-
-                if (!dbus_message_iter_close_container(&iter, &sub))
-                        goto oom;
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ListUsers")) {
-                User *user;
-                Iterator i;
-                DBusMessageIter iter, sub;
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
-
-                dbus_message_iter_init_append(reply, &iter);
-
-                if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(uso)", &sub))
-                        goto oom;
-
-                HASHMAP_FOREACH(user, m->users, i) {
-                        _cleanup_free_ char *p = NULL;
-                        DBusMessageIter sub2;
-                        uint32_t uid;
-
-                        if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
-                                goto oom;
-
-                        uid = user->uid;
-
-                        p = user_bus_path(user);
-                        if (!p)
-                                goto oom;
-
-                        if (!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT32, &uid) ||
-                            !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &user->name) ||
-                            !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_OBJECT_PATH, &p)) {
-                                free(p);
-                                goto oom;
-                        }
-
-                        if (!dbus_message_iter_close_container(&sub, &sub2))
-                                goto oom;
-                }
-
-                if (!dbus_message_iter_close_container(&iter, &sub))
-                        goto oom;
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ListSeats")) {
-                Seat *seat;
-                Iterator i;
-                DBusMessageIter iter, sub;
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
-
-                dbus_message_iter_init_append(reply, &iter);
-
-                if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(so)", &sub))
-                        goto oom;
-
-                HASHMAP_FOREACH(seat, m->seats, i) {
-                        _cleanup_free_ char *p = NULL;
-                        DBusMessageIter sub2;
-
-                        if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
-                                goto oom;
-
-                        p = seat_bus_path(seat);
-                        if (!p)
-                                goto oom;
-
-                        if (!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &seat->id) ||
-                            !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_OBJECT_PATH, &p)) {
-                                free(p);
-                                goto oom;
-                        }
-
-                        if (!dbus_message_iter_close_container(&sub, &sub2))
-                                goto oom;
-                }
-
-                if (!dbus_message_iter_close_container(&iter, &sub))
-                        goto oom;
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ListInhibitors")) {
-                Inhibitor *inhibitor;
-                Iterator i;
-                DBusMessageIter iter, sub;
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
-
-                dbus_message_iter_init_append(reply, &iter);
-
-                if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(ssssuu)", &sub))
-                        goto oom;
-
-                HASHMAP_FOREACH(inhibitor, m->inhibitors, i) {
-                        DBusMessageIter sub2;
-                        dbus_uint32_t uid, pid;
-                        const char *what, *who, *why, *mode;
-
-                        if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
-                                goto oom;
-
-                        what = strempty(inhibit_what_to_string(inhibitor->what));
-                        who = strempty(inhibitor->who);
-                        why = strempty(inhibitor->why);
-                        mode = strempty(inhibit_mode_to_string(inhibitor->mode));
-                        uid = (dbus_uint32_t) inhibitor->uid;
-                        pid = (dbus_uint32_t) inhibitor->pid;
+        return method_do_shutdown_or_sleep(
+                        m, message,
+                        SPECIAL_POWEROFF_TARGET,
+                        INHIBIT_SHUTDOWN,
+                        "org.freedesktop.login1.power-off",
+                        "org.freedesktop.login1.power-off-multiple-sessions",
+                        "org.freedesktop.login1.power-off-ignore-inhibit",
+                        NULL,
+                        method_poweroff);
+}
 
-                        if (!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &what) ||
-                            !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &who) ||
-                            !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &why) ||
-                            !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &mode) ||
-                            !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT32, &uid) ||
-                            !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT32, &pid))
-                                goto oom;
+static int method_reboot(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Manager *m = userdata;
 
-                        if (!dbus_message_iter_close_container(&sub, &sub2))
-                                goto oom;
-                }
+        return method_do_shutdown_or_sleep(
+                        m, message,
+                        SPECIAL_REBOOT_TARGET,
+                        INHIBIT_SHUTDOWN,
+                        "org.freedesktop.login1.reboot",
+                        "org.freedesktop.login1.reboot-multiple-sessions",
+                        "org.freedesktop.login1.reboot-ignore-inhibit",
+                        NULL,
+                        method_reboot);
+}
 
-                if (!dbus_message_iter_close_container(&iter, &sub))
-                        goto oom;
+static int method_suspend(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Manager *m = userdata;
 
+        return method_do_shutdown_or_sleep(
+                        m, message,
+                        SPECIAL_SUSPEND_TARGET,
+                        INHIBIT_SLEEP,
+                        "org.freedesktop.login1.suspend",
+                        "org.freedesktop.login1.suspend-multiple-sessions",
+                        "org.freedesktop.login1.suspend-ignore-inhibit",
+                        "suspend",
+                        method_suspend);
+}
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "Inhibit")) {
+static int method_hibernate(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Manager *m = userdata;
 
-                r = bus_manager_inhibit(m, connection, message, &error, &reply);
+        return method_do_shutdown_or_sleep(
+                        m, message,
+                        SPECIAL_HIBERNATE_TARGET,
+                        INHIBIT_SLEEP,
+                        "org.freedesktop.login1.hibernate",
+                        "org.freedesktop.login1.hibernate-multiple-sessions",
+                        "org.freedesktop.login1.hibernate-ignore-inhibit",
+                        "hibernate",
+                        method_hibernate);
+}
 
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, &error, r);
+static int method_hybrid_sleep(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Manager *m = userdata;
 
+        return method_do_shutdown_or_sleep(
+                        m, message,
+                        SPECIAL_HYBRID_SLEEP_TARGET,
+                        INHIBIT_SLEEP,
+                        "org.freedesktop.login1.hibernate",
+                        "org.freedesktop.login1.hibernate-multiple-sessions",
+                        "org.freedesktop.login1.hibernate-ignore-inhibit",
+                        "hybrid-sleep",
+                        method_hybrid_sleep);
+}
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "CreateSession")) {
+static int method_can_shutdown_or_sleep(
+                Manager *m,
+                sd_bus_message *message,
+                InhibitWhat w,
+                const char *action,
+                const char *action_multiple_sessions,
+                const char *action_ignore_inhibit,
+                const char *sleep_verb) {
 
-                r = bus_manager_create_session(m, message);
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+        bool multiple_sessions, challenge, blocked;
+        const char *result = NULL;
+        uid_t uid;
+        int r;
 
-                /* Don't delay the work on OOM here, since it might be
-                 * triggered by a low RLIMIT_NOFILE here (since we
-                 * send a dupped fd to the client), and we'd rather
-                 * see this fail quickly then be retried later */
+        assert(m);
+        assert(message);
+        assert(w >= 0);
+        assert(w <= _INHIBIT_WHAT_MAX);
+        assert(action);
+        assert(action_multiple_sessions);
+        assert(action_ignore_inhibit);
 
+        if (sleep_verb) {
+                r = can_sleep(sleep_verb);
                 if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
+                        return sd_bus_reply_method_errno(m->bus, message, r, NULL);
+                if (r == 0)
+                        return sd_bus_reply_method_return(m->bus, message, "s", "na");
+        }
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ReleaseSession")) {
-                const char *name;
-                Session *session;
+        r = sd_bus_get_owner_uid(m->bus, sd_bus_message_get_sender(message), &uid);
+        if (r < 0)
+                return sd_bus_reply_method_errno(m->bus, message, r, NULL);
 
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_STRING, &name,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
-
-                session = hashmap_get(m->sessions, name);
-                if (!session)
-                        return bus_send_error_reply(connection, message, &error, -ENOENT);
-
-                /* We use the FIFO to detect stray sessions where the
-                process invoking PAM dies abnormally. We need to make
-                sure that that process is not killed if at the clean
-                end of the session it closes the FIFO. Hence, with
-                this call explicitly turn off the FIFO logic, so that
-                the PAM code can finish clean up on its own */
-                session_remove_fifo(session);
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ActivateSession")) {
-                const char *name;
-                Session *session;
-
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_STRING, &name,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
+        r = have_multiple_sessions(m, uid);
+        if (r < 0)
+                return sd_bus_reply_method_errno(m->bus, message, r, NULL);
 
-                session = hashmap_get(m->sessions, name);
-                if (!session)
-                        return bus_send_error_reply(connection, message, &error, -ENOENT);
+        multiple_sessions = r > 0;
+        blocked = manager_is_inhibited(m, w, INHIBIT_BLOCK, NULL, false, true, uid);
 
-                r = session_activate(session);
+        if (multiple_sessions) {
+                r = bus_verify_polkit(m->bus, message, action_multiple_sessions, false, &challenge, &error);
                 if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+                        return sd_bus_reply_method_errno(m->bus, message, r, &error);
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ActivateSessionOnSeat")) {
-                const char *session_name, *seat_name;
-                Session *session;
-                Seat *seat;
-
-                /* Same as ActivateSession() but refuses to work if
-                 * the seat doesn't match */
-
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_STRING, &session_name,
-                                    DBUS_TYPE_STRING, &seat_name,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
-
-                session = hashmap_get(m->sessions, session_name);
-                if (!session)
-                        return bus_send_error_reply(connection, message, &error, -ENOENT);
-
-                seat = hashmap_get(m->seats, seat_name);
-                if (!seat)
-                        return bus_send_error_reply(connection, message, &error, -ENOENT);
-
-                if (session->seat != seat)
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
+                if (r > 0)
+                        result = "yes";
+                else if (challenge)
+                        result = "challenge";
+                else
+                        result = "no";
+        }
 
-                r = session_activate(session);
+        if (blocked) {
+                r = bus_verify_polkit(m->bus, message, action_ignore_inhibit, false, &challenge, &error);
                 if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "LockSession") ||
-                   dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "UnlockSession")) {
-                const char *name;
-                Session *session;
-
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_STRING, &name,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
+                        return sd_bus_reply_method_errno(m->bus, message, r, &error);
 
-                session = hashmap_get(m->sessions, name);
-                if (!session)
-                        return bus_send_error_reply(connection, message, NULL, -ENOENT);
-
-                if (session_send_lock(session, streq(dbus_message_get_member(message), "LockSession")) < 0)
-                        goto oom;
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+                if (r > 0 && !result)
+                        result = "yes";
+                else if (challenge && (!result || streq(result, "yes")))
+                        result = "challenge";
+                else
+                        result = "no";
+        }
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "LockSessions") ||
-                   dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "UnlockSessions")) {
+        if (!multiple_sessions && !blocked) {
+                /* If neither inhibit nor multiple sessions
+                 * apply then just check the normal policy */
 
-                r = session_send_lock_all(m, streq(dbus_message_get_member(message), "LockSessions"));
+                r = bus_verify_polkit(m->bus, message, action, false, &challenge, &error);
                 if (r < 0)
-                        bus_send_error_reply(connection, message, NULL, r);
+                        return sd_bus_reply_method_errno(m->bus, message, r, &error);
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+                if (r > 0)
+                        result = "yes";
+                else if (challenge)
+                        result = "challenge";
+                else
+                        result = "no";
+        }
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "KillSession")) {
-                const char *swho;
-                int32_t signo;
-                KillWho who;
-                const char *name;
-                Session *session;
+        return sd_bus_reply_method_return(m->bus, message, "s", result);
+}
 
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_STRING, &name,
-                                    DBUS_TYPE_STRING, &swho,
-                                    DBUS_TYPE_INT32, &signo,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
-
-                if (isempty(swho))
-                        who = KILL_ALL;
-                else {
-                        who = kill_who_from_string(swho);
-                        if (who < 0)
-                                return bus_send_error_reply(connection, message, &error, -EINVAL);
-                }
+static int method_can_poweroff(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Manager *m = userdata;
 
-                if (signo <= 0 || signo >= _NSIG)
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
+        return method_can_shutdown_or_sleep(
+                        m, message,
+                        INHIBIT_SHUTDOWN,
+                        "org.freedesktop.login1.power-off",
+                        "org.freedesktop.login1.power-off-multiple-sessions",
+                        "org.freedesktop.login1.power-off-ignore-inhibit",
+                        NULL);
+}
 
-                session = hashmap_get(m->sessions, name);
-                if (!session)
-                        return bus_send_error_reply(connection, message, &error, -ENOENT);
+static int method_can_reboot(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Manager *m = userdata;
 
-                r = session_kill(session, who, signo);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
+        return method_can_shutdown_or_sleep(
+                        m, message,
+                        INHIBIT_SHUTDOWN,
+                        "org.freedesktop.login1.reboot",
+                        "org.freedesktop.login1.reboot-multiple-sessions",
+                        "org.freedesktop.login1.reboot-ignore-inhibit",
+                        NULL);
+}
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+static int method_can_suspend(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Manager *m = userdata;
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "KillUser")) {
-                uint32_t uid;
-                User *user;
-                int32_t signo;
+        return method_can_shutdown_or_sleep(
+                        m, message,
+                        INHIBIT_SLEEP,
+                        "org.freedesktop.login1.suspend",
+                        "org.freedesktop.login1.suspend-multiple-sessions",
+                        "org.freedesktop.login1.suspend-ignore-inhibit",
+                        "suspend");
+}
 
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_UINT32, &uid,
-                                    DBUS_TYPE_INT32, &signo,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
+static int method_can_hibernate(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Manager *m = userdata;
 
-                if (signo <= 0 || signo >= _NSIG)
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
+        return method_can_shutdown_or_sleep(
+                        m, message,
+                        INHIBIT_SLEEP,
+                        "org.freedesktop.login1.hibernate",
+                        "org.freedesktop.login1.hibernate-multiple-sessions",
+                        "org.freedesktop.login1.hibernate-ignore-inhibit",
+                        "hibernate");
+}
 
-                user = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
-                if (!user)
-                        return bus_send_error_reply(connection, message, &error, -ENOENT);
+static int method_can_hybrid_sleep(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Manager *m = userdata;
 
-                r = user_kill(user, signo);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
+        return method_can_shutdown_or_sleep(
+                        m, message,
+                        INHIBIT_SLEEP,
+                        "org.freedesktop.login1.hibernate",
+                        "org.freedesktop.login1.hibernate-multiple-sessions",
+                        "org.freedesktop.login1.hibernate-ignore-inhibit",
+                        "hybrid-sleep");
+}
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+static int method_inhibit(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+        const char *who, *why, *what, *mode;
+        _cleanup_free_ char *id = NULL;
+        _cleanup_close_ int fifo_fd = -1;
+        Manager *m = userdata;
+        Inhibitor *i = NULL;
+        InhibitMode mm;
+        InhibitWhat w;
+        pid_t pid;
+        uid_t uid;
+        int r;
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "TerminateSession")) {
-                const char *name;
-                Session *session;
+        assert(bus);
+        assert(message);
+        assert(m);
 
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_STRING, &name,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
+        r = sd_bus_message_read(message, "ssss", &what, &who, &why, &mode);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-                session = hashmap_get(m->sessions, name);
-                if (!session)
-                        return bus_send_error_reply(connection, message, &error, -ENOENT);
+        w = inhibit_what_from_string(what);
+        if (w <= 0)
+                return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid what specification %s", what);
 
-                r = session_stop(session);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
+        mm = inhibit_mode_from_string(mode);
+        if (mm < 0)
+                return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid mode specification %s", mode);
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+        /* Delay is only supported for shutdown/sleep */
+        if (mm == INHIBIT_DELAY && (w & ~(INHIBIT_SHUTDOWN|INHIBIT_SLEEP)))
+                return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Delay inhibitors only supported for shutdown and sleep");
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "TerminateUser")) {
-                uint32_t uid;
-                User *user;
+        /* Don't allow taking delay locks while we are already
+         * executing the operation. We shouldn't create the impression
+         * that the lock was successful if the machine is about to go
+         * down/suspend any moment. */
+        if (m->action_what & w)
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_OPERATION_IN_PROGRESS, "The operation inhibition has been requested for is already running");
+
+        r = bus_verify_polkit_async(bus, &m->polkit_registry, message,
+                                    w == INHIBIT_SHUTDOWN             ? (mm == INHIBIT_BLOCK ? "org.freedesktop.login1.inhibit-block-shutdown" : "org.freedesktop.login1.inhibit-delay-shutdown") :
+                                    w == INHIBIT_SLEEP                ? (mm == INHIBIT_BLOCK ? "org.freedesktop.login1.inhibit-block-sleep"    : "org.freedesktop.login1.inhibit-delay-sleep") :
+                                    w == INHIBIT_IDLE                 ? "org.freedesktop.login1.inhibit-block-idle" :
+                                    w == INHIBIT_HANDLE_POWER_KEY     ? "org.freedesktop.login1.inhibit-handle-power-key" :
+                                    w == INHIBIT_HANDLE_SUSPEND_KEY   ? "org.freedesktop.login1.inhibit-handle-suspend-key" :
+                                    w == INHIBIT_HANDLE_HIBERNATE_KEY ? "org.freedesktop.login1.inhibit-handle-hibernate-key" :
+                                                                        "org.freedesktop.login1.inhibit-handle-lid-switch",
+                                    false, &error, method_inhibit, m);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, &error);
+        if (r == 0)
+                return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
 
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_UINT32, &uid,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
+        r = sd_bus_get_owner_uid(m->bus, sd_bus_message_get_sender(message), &uid);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-                user = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
-                if (!user)
-                        return bus_send_error_reply(connection, message, &error, -ENOENT);
+        r = sd_bus_get_owner_pid(m->bus, sd_bus_message_get_sender(message), &pid);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-                r = user_stop(user);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
+        do {
+                free(id);
+                id = NULL;
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+                if (asprintf(&id, "%lu", ++m->inhibit_counter) < 0)
+                        return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "TerminateSeat")) {
-                const char *name;
-                Seat *seat;
+        } while (hashmap_get(m->inhibitors, id));
 
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_STRING, &name,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
+        r = manager_add_inhibitor(m, id, &i);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-                seat = hashmap_get(m->seats, name);
-                if (!seat)
-                        return bus_send_error_reply(connection, message, &error, -ENOENT);
+        i->what = w;
+        i->mode = mm;
+        i->pid = pid;
+        i->uid = uid;
+        i->why = strdup(why);
+        i->who = strdup(who);
 
-                r = seat_stop_sessions(seat);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
+        if (!i->why || !i->who) {
+                r = sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
+                goto fail;
+        }
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+        fifo_fd = inhibitor_create_fifo(i);
+        if (fifo_fd < 0) {
+                r = sd_bus_reply_method_errno(bus, message, fifo_fd, NULL);
+                goto fail;
+        }
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "SetUserLinger")) {
-                uint32_t uid;
-                struct passwd *pw;
-                dbus_bool_t b, interactive;
-                char *path;
+        inhibitor_start(i);
 
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_UINT32, &uid,
-                                    DBUS_TYPE_BOOLEAN, &b,
-                                    DBUS_TYPE_BOOLEAN, &interactive,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
-
-                errno = 0;
-                pw = getpwuid(uid);
-                if (!pw)
-                        return bus_send_error_reply(connection, message, NULL, errno ? -errno : -EINVAL);
-
-                r = verify_polkit(connection, message, "org.freedesktop.login1.set-user-linger", interactive, NULL, &error);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, &error, r);
+        return sd_bus_reply_method_return(bus, message, "h", fifo_fd);
 
-                mkdir_p_label("/var/lib/systemd", 0755);
+fail:
+        if (i)
+                inhibitor_free(i);
 
-                r = mkdir_safe_label("/var/lib/systemd/linger", 0755, 0, 0);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, &error, r);
+        return r;
+}
 
-                path = strappend("/var/lib/systemd/linger/", pw->pw_name);
-                if (!path)
-                        goto oom;
+const sd_bus_vtable manager_vtable[] = {
+        SD_BUS_VTABLE_START(0),
+
+        SD_BUS_PROPERTY("NAutoVTs", "u", NULL, offsetof(Manager, n_autovts), 0),
+        SD_BUS_PROPERTY("KillOnlyUsers", "as", NULL, offsetof(Manager, kill_only_users), 0),
+        SD_BUS_PROPERTY("KillExcludeUsers", "as", NULL, offsetof(Manager, kill_exclude_users), 0),
+        SD_BUS_PROPERTY("KillUserProcesses", "b", NULL, offsetof(Manager, kill_user_processes), 0),
+        SD_BUS_PROPERTY("IdleHint", "b", property_get_idle_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+        SD_BUS_PROPERTY("IdleSinceHint", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+        SD_BUS_PROPERTY("IdleSinceHintMonotonic", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+        SD_BUS_PROPERTY("BlockInhibited", "s", property_get_inhibited, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+        SD_BUS_PROPERTY("DelayInhibited", "s", property_get_inhibited, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+        SD_BUS_PROPERTY("InhibitDelayMaxUSec", "t", NULL, offsetof(Manager, inhibit_delay_max), 0),
+        SD_BUS_PROPERTY("HandlePowerKey", "s", property_get_handle_action, offsetof(Manager, handle_power_key), 0),
+        SD_BUS_PROPERTY("HandleSuspendKey", "s", property_get_handle_action, offsetof(Manager, handle_suspend_key), 0),
+        SD_BUS_PROPERTY("HandleHibernateKey", "s", property_get_handle_action, offsetof(Manager, handle_hibernate_key), 0),
+        SD_BUS_PROPERTY("HandleLidSwitch", "s", property_get_handle_action, offsetof(Manager, handle_lid_switch), 0),
+        SD_BUS_PROPERTY("IdleAction", "s", property_get_handle_action, offsetof(Manager, idle_action), 0),
+        SD_BUS_PROPERTY("IdleActionUSec", "t", NULL, offsetof(Manager, idle_action_usec), 0),
+        SD_BUS_PROPERTY("PreparingForShutdown", "b", property_get_preparing, 0, 0),
+        SD_BUS_PROPERTY("PreparingForSleep", "b", property_get_preparing, 0, 0),
+
+        SD_BUS_METHOD("GetSession", "s", "o", method_get_session, 0),
+        SD_BUS_METHOD("GetSessionByPID", "u", "o", method_get_session_by_pid, 0),
+        SD_BUS_METHOD("GetUser", "u", "o", method_get_user, 0),
+        SD_BUS_METHOD("GetUserByPID", "u", "o", method_get_user_by_pid, 0),
+        SD_BUS_METHOD("GetSeat", "s", "o", method_get_seat, 0),
+        SD_BUS_METHOD("ListSessions", NULL, "a(susso)", method_list_sessions, 0),
+        SD_BUS_METHOD("ListUsers", NULL, "a(uso)", method_list_users, 0),
+        SD_BUS_METHOD("ListSeats", NULL, "a(so)", method_list_seats, 0),
+        SD_BUS_METHOD("ListInhibitors", NULL, "a(ssssuu)", method_list_inhibitors, 0),
+        SD_BUS_METHOD("CreateSession", "uussssussbssa(sv)", "soshsub", method_create_session, 0),
+        SD_BUS_METHOD("ReleaseSession", "s", NULL, method_release_session, 0),
+        SD_BUS_METHOD("ActivateSession", "s", NULL, method_activate_session, 0),
+        SD_BUS_METHOD("ActivateSessionOnSeat", "ss", NULL, method_activate_session_on_seat, 0),
+        SD_BUS_METHOD("LockSession", "s", NULL, method_lock_session, 0),
+        SD_BUS_METHOD("UnlockSession", "s", NULL, method_lock_session, 0),
+        SD_BUS_METHOD("LockSessions", NULL, NULL, method_lock_sessions, 0),
+        SD_BUS_METHOD("UnlockSessions", NULL, NULL, method_lock_sessions, 0),
+        SD_BUS_METHOD("KillSession", "ssi", NULL, method_kill_session, 0),
+        SD_BUS_METHOD("KillUser", "ui", NULL, method_kill_user, 0),
+        SD_BUS_METHOD("TerminateSession", "s", NULL, method_terminate_session, 0),
+        SD_BUS_METHOD("TerminateUser", "u", NULL, method_terminate_user, 0),
+        SD_BUS_METHOD("TerminateSeat", "s", NULL, method_terminate_seat, 0),
+        SD_BUS_METHOD("SetUserLinger", "ubb", NULL, method_set_user_linger, 0),
+        SD_BUS_METHOD("AttachDevice", "ssb", NULL, method_attach_device, 0),
+        SD_BUS_METHOD("FlushDevices", "b", NULL, method_flush_devices, 0),
+        SD_BUS_METHOD("PowerOff", "b", NULL, method_poweroff, 0),
+        SD_BUS_METHOD("Reboot", "b", NULL, method_reboot, 0),
+        SD_BUS_METHOD("Suspend", "b", NULL, method_suspend, 0),
+        SD_BUS_METHOD("Hibernate", "b", NULL, method_hibernate, 0),
+        SD_BUS_METHOD("HybridSleep", "b", NULL, method_hybrid_sleep, 0),
+        SD_BUS_METHOD("CanPowerOff", NULL, "s", method_can_poweroff, 0),
+        SD_BUS_METHOD("CanReboot", NULL, "s", method_can_reboot, 0),
+        SD_BUS_METHOD("CanSuspend", NULL, "s", method_can_suspend, 0),
+        SD_BUS_METHOD("CanHibernate", NULL, "s", method_can_hibernate, 0),
+        SD_BUS_METHOD("CanHybridSleep", NULL, "s", method_can_hybrid_sleep, 0),
+        SD_BUS_METHOD("Inhibit", "ssss", "h", method_inhibit, 0),
+
+        SD_BUS_SIGNAL("SessionNew", "so", 0),
+        SD_BUS_SIGNAL("SessionRemoved", "so", 0),
+        SD_BUS_SIGNAL("UserNew", "uo", 0),
+        SD_BUS_SIGNAL("UserRemoved", "uo", 0),
+        SD_BUS_SIGNAL("SeatNew", "so", 0),
+        SD_BUS_SIGNAL("SeatRemoved", "so", 0),
+        SD_BUS_SIGNAL("PrepareForShutdown", "b", 0),
+        SD_BUS_SIGNAL("PrepareForSleep", "b", 0),
+
+        SD_BUS_VTABLE_END
+};
 
-                if (b) {
-                        User *u;
+int match_job_removed(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        const char *path, *result, *unit;
+        Manager *m = userdata;
+        Session *session;
+        uint32_t id;
+        User *user;
+        int r;
 
-                        r = touch(path);
-                        free(path);
+        assert(bus);
+        assert(message);
+        assert(m);
 
-                        if (r < 0)
-                                return bus_send_error_reply(connection, message, &error, r);
+        r = sd_bus_message_read(message, "uoss", &id, &path, &unit, &result);
+        if (r < 0) {
+                log_error("Failed to parse JobRemoved message: %s", strerror(-r));
+                return 0;
+        }
 
-                        if (manager_add_user_by_uid(m, uid, &u) >= 0)
-                                user_start(u);
+        if (m->action_job && streq(m->action_job, path)) {
+                log_info("Operation finished.");
 
-                } else {
-                        User *u;
+                /* Tell people that they now may take a lock again */
+                send_prepare_for(m, m->action_what, false);
 
-                        r = unlink(path);
-                        free(path);
+                free(m->action_job);
+                m->action_job = NULL;
+                m->action_unit = NULL;
+                m->action_what = 0;
+                return 0;
+        }
 
-                        if (r < 0 && errno != ENOENT)
-                                return bus_send_error_reply(connection, message, &error, -errno);
+        session = hashmap_get(m->session_units, unit);
+        if (session) {
 
-                        u = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
-                        if (u)
-                                user_add_to_gc_queue(u);
+                if (streq_ptr(path, session->scope_job)) {
+                        free(session->scope_job);
+                        session->scope_job = NULL;
                 }
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "AttachDevice")) {
-                const char *sysfs, *seat;
-                dbus_bool_t interactive;
-
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_STRING, &seat,
-                                    DBUS_TYPE_STRING, &sysfs,
-                                    DBUS_TYPE_BOOLEAN, &interactive,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
-
-                if (!path_startswith(sysfs, "/sys") || !seat_name_is_valid(seat))
-                        return bus_send_error_reply(connection, message, NULL, -EINVAL);
-
-                r = verify_polkit(connection, message, "org.freedesktop.login1.attach-device", interactive, NULL, &error);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, &error, r);
-
-                r = attach_device(m, seat, sysfs);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, -EINVAL);
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
-
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "FlushDevices")) {
-                dbus_bool_t interactive;
-
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_BOOLEAN, &interactive,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
-
-                r = verify_polkit(connection, message, "org.freedesktop.login1.flush-devices", interactive, NULL, &error);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, &error, r);
-
-                r = flush_devices(m);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, -EINVAL);
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "PowerOff")) {
-
-                r = bus_manager_do_shutdown_or_sleep(
-                                m, connection, message,
-                                SPECIAL_POWEROFF_TARGET,
-                                INHIBIT_SHUTDOWN,
-                                "org.freedesktop.login1.power-off",
-                                "org.freedesktop.login1.power-off-multiple-sessions",
-                                "org.freedesktop.login1.power-off-ignore-inhibit",
-                                NULL,
-                                &error, &reply);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, &error, r);
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "Reboot")) {
-                r = bus_manager_do_shutdown_or_sleep(
-                                m, connection, message,
-                                SPECIAL_REBOOT_TARGET,
-                                INHIBIT_SHUTDOWN,
-                                "org.freedesktop.login1.reboot",
-                                "org.freedesktop.login1.reboot-multiple-sessions",
-                                "org.freedesktop.login1.reboot-ignore-inhibit",
-                                NULL,
-                                &error, &reply);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, &error, r);
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "Suspend")) {
-                r = bus_manager_do_shutdown_or_sleep(
-                                m, connection, message,
-                                SPECIAL_SUSPEND_TARGET,
-                                INHIBIT_SLEEP,
-                                "org.freedesktop.login1.suspend",
-                                "org.freedesktop.login1.suspend-multiple-sessions",
-                                "org.freedesktop.login1.suspend-ignore-inhibit",
-                                "suspend",
-                                &error, &reply);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, &error, r);
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "Hibernate")) {
-                r = bus_manager_do_shutdown_or_sleep(
-                                m, connection, message,
-                                SPECIAL_HIBERNATE_TARGET,
-                                INHIBIT_SLEEP,
-                                "org.freedesktop.login1.hibernate",
-                                "org.freedesktop.login1.hibernate-multiple-sessions",
-                                "org.freedesktop.login1.hibernate-ignore-inhibit",
-                                "hibernate",
-                                &error, &reply);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, &error, r);
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "HybridSleep")) {
-                r = bus_manager_do_shutdown_or_sleep(
-                                m, connection, message,
-                                SPECIAL_HYBRID_SLEEP_TARGET,
-                                INHIBIT_SLEEP,
-                                "org.freedesktop.login1.hibernate",
-                                "org.freedesktop.login1.hibernate-multiple-sessions",
-                                "org.freedesktop.login1.hibernate-ignore-inhibit",
-                                "hybrid-sleep",
-                                &error, &reply);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, &error, r);
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "CanPowerOff")) {
-
-                r = bus_manager_can_shutdown_or_sleep(
-                                m, connection, message,
-                                INHIBIT_SHUTDOWN,
-                                "org.freedesktop.login1.power-off",
-                                "org.freedesktop.login1.power-off-multiple-sessions",
-                                "org.freedesktop.login1.power-off-ignore-inhibit",
-                                NULL,
-                                &error, &reply);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, &error, r);
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "CanReboot")) {
-                r = bus_manager_can_shutdown_or_sleep(
-                                m, connection, message,
-                                INHIBIT_SHUTDOWN,
-                                "org.freedesktop.login1.reboot",
-                                "org.freedesktop.login1.reboot-multiple-sessions",
-                                "org.freedesktop.login1.reboot-ignore-inhibit",
-                                NULL,
-                                &error, &reply);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, &error, r);
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "CanSuspend")) {
-                r = bus_manager_can_shutdown_or_sleep(
-                                m, connection, message,
-                                INHIBIT_SLEEP,
-                                "org.freedesktop.login1.suspend",
-                                "org.freedesktop.login1.suspend-multiple-sessions",
-                                "org.freedesktop.login1.suspend-ignore-inhibit",
-                                "suspend",
-                                &error, &reply);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, &error, r);
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "CanHibernate")) {
-                r = bus_manager_can_shutdown_or_sleep(
-                                m, connection, message,
-                                INHIBIT_SLEEP,
-                                "org.freedesktop.login1.hibernate",
-                                "org.freedesktop.login1.hibernate-multiple-sessions",
-                                "org.freedesktop.login1.hibernate-ignore-inhibit",
-                                "hibernate",
-                                &error, &reply);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, &error, r);
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "CanHybridSleep")) {
-                r = bus_manager_can_shutdown_or_sleep(
-                                m, connection, message,
-                                INHIBIT_SLEEP,
-                                "org.freedesktop.login1.hibernate",
-                                "org.freedesktop.login1.hibernate-multiple-sessions",
-                                "org.freedesktop.login1.hibernate-ignore-inhibit",
-                                "hybrid-sleep",
-                                &error, &reply);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, &error, r);
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.DBus.Introspectable", "Introspect")) {
-                char *introspection = NULL;
-                FILE *f;
-                Iterator i;
-                Session *session;
-                Seat *seat;
-                User *user;
-                size_t size;
-                char *p;
-
-                if (!(reply = dbus_message_new_method_return(message)))
-                        goto oom;
-
-                /* We roll our own introspection code here, instead of
-                 * relying on bus_default_message_handler() because we
-                 * need to generate our introspection string
-                 * dynamically. */
-
-                if (!(f = open_memstream(&introspection, &size)))
-                        goto oom;
+                if (session->started) {
+                        if (streq(result, "done"))
+                                session_send_create_reply(session, NULL);
+                        else {
+                                _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 
-                fputs(INTROSPECTION_BEGIN, f);
-
-                HASHMAP_FOREACH(seat, m->seats, i) {
-                        p = bus_path_escape(seat->id);
-
-                        if (p) {
-                                fprintf(f, "<node name=\"seat/%s\"/>", p);
-                                free(p);
+                                sd_bus_error_setf(&error, BUS_ERROR_JOB_FAILED, "Start job for unit %s failed with '%s'", unit, result);
+                                session_send_create_reply(session, &error);
                         }
-                }
-
-                HASHMAP_FOREACH(user, m->users, i)
-                        fprintf(f, "<node name=\"user/_%llu\"/>", (unsigned long long) user->uid);
+                } else
+                        session_save(session);
 
-                HASHMAP_FOREACH(session, m->sessions, i) {
-                        p = bus_path_escape(session->id);
-
-                        if (p) {
-                                fprintf(f, "<node name=\"session/%s\"/>", p);
-                                free(p);
-                        }
-                }
+                session_add_to_gc_queue(session);
+        }
 
-                fputs(INTROSPECTION_END, f);
+        user = hashmap_get(m->user_units, unit);
+        if (user) {
 
-                if (ferror(f)) {
-                        fclose(f);
-                        free(introspection);
-                        goto oom;
+                if (streq_ptr(path, user->service_job)) {
+                        free(user->service_job);
+                        user->service_job = NULL;
                 }
 
-                fclose(f);
-
-                if (!introspection)
-                        goto oom;
-
-                if (!dbus_message_append_args(reply, DBUS_TYPE_STRING, &introspection, DBUS_TYPE_INVALID)) {
-                        free(introspection);
-                        goto oom;
+                if (streq_ptr(path, user->slice_job)) {
+                        free(user->slice_job);
+                        user->slice_job = NULL;
                 }
 
-                free(introspection);
-        } else {
-                const BusBoundProperties bps[] = {
-                        { "org.freedesktop.login1.Manager", bus_login_manager_properties, m },
-                        { NULL, }
-                };
-                return bus_default_message_handler(connection, message, NULL, INTERFACES_LIST, bps);
-        }
-
-        if (reply) {
-                if (!bus_maybe_send_reply(connection, message, reply))
-                        goto oom;
+                user_save(user);
+                user_add_to_gc_queue(user);
         }
 
-        return DBUS_HANDLER_RESULT_HANDLED;
-
-oom:
-        dbus_error_free(&error);
-
-        return DBUS_HANDLER_RESULT_NEED_MEMORY;
+        return 0;
 }
 
-const DBusObjectPathVTable bus_manager_vtable = {
-        .message_function = manager_message_handler
-};
-
-DBusHandlerResult bus_message_filter(
-                DBusConnection *connection,
-                DBusMessage *message,
-                void *userdata) {
-
+int match_unit_removed(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        const char *path, *unit;
         Manager *m = userdata;
-        DBusError error;
+        Session *session;
+        User *user;
+        int r;
 
-        assert(m);
-        assert(connection);
+        assert(bus);
         assert(message);
+        assert(m);
 
-        dbus_error_init(&error);
-
-        log_debug("Got message: %s %s %s", strna(dbus_message_get_sender(message)), strna(dbus_message_get_interface(message)), strna(dbus_message_get_member(message)));
-
-        if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "JobRemoved")) {
-                const char *path, *result, *unit;
-                uint32_t id;
-
-                if (!dbus_message_get_args(message, &error,
-                                           DBUS_TYPE_UINT32, &id,
-                                           DBUS_TYPE_OBJECT_PATH, &path,
-                                           DBUS_TYPE_STRING, &unit,
-                                           DBUS_TYPE_STRING, &result,
-                                           DBUS_TYPE_INVALID)) {
-                        log_error("Failed to parse JobRemoved message: %s", bus_error_message(&error));
-                        goto finish;
-                }
-
-                if (m->action_job && streq(m->action_job, path)) {
-                        log_info("Operation finished.");
-
-                        /* Tell people that they now may take a lock again */
-                        send_prepare_for(m, m->action_what, false);
-
-                        free(m->action_job);
-                        m->action_job = NULL;
-                        m->action_unit = NULL;
-                        m->action_what = 0;
+        r = sd_bus_message_read(message, "so", &unit, &path);
+        if (r < 0) {
+                log_error("Failed to parse UnitRemoved message: %s", strerror(-r));
+                return 0;
+        }
 
-                } else {
-                        Session *s;
-                        User *u;
-
-                        s = hashmap_get(m->session_units, unit);
-                        if (s) {
-                                if (streq_ptr(path, s->scope_job)) {
-                                        free(s->scope_job);
-                                        s->scope_job = NULL;
-
-                                        if (s->started) {
-                                                if (streq(result, "done"))
-                                                        session_send_create_reply(s, NULL);
-                                                else {
-                                                        dbus_set_error(&error, BUS_ERROR_JOB_FAILED, "Start job for unit %s failed with '%s'", unit, result);
-                                                        session_send_create_reply(s, &error);
-                                                }
-                                        } else
-                                                session_save(s);
-                                }
-
-                                session_add_to_gc_queue(s);
-                        }
+        session = hashmap_get(m->session_units, unit);
+        if (session)
+                session_add_to_gc_queue(session);
 
-                        u = hashmap_get(m->user_units, unit);
-                        if (u) {
-                                if (streq_ptr(path, u->service_job)) {
-                                        free(u->service_job);
-                                        u->service_job = NULL;
-                                }
+        user = hashmap_get(m->user_units, unit);
+        if (user)
+                user_add_to_gc_queue(user);
 
-                                if (streq_ptr(path, u->slice_job)) {
-                                        free(u->slice_job);
-                                        u->slice_job = NULL;
-                                }
+        return 0;
+}
 
-                                user_save(u);
-                                user_add_to_gc_queue(u);
-                        }
-                }
+int match_properties_changed(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        _cleanup_free_ char *unit = NULL;
+        Manager *m = userdata;
+        const char *path;
+        Session *session;
+        User *user;
 
-        } else if (dbus_message_is_signal(message, "org.freedesktop.DBus.Properties", "PropertiesChanged")) {
+        assert(bus);
+        assert(message);
+        assert(m);
 
-                _cleanup_free_ char *unit = NULL;
-                const char *path;
+        path = sd_bus_message_get_path(message);
+        if (!path)
+                return 0;
 
-                path = dbus_message_get_path(message);
-                if (!path)
-                        goto finish;
+        unit_name_from_dbus_path(path, &unit);
+        if (!unit)
+                return 0;
 
-                unit_name_from_dbus_path(path, &unit);
-                if (unit) {
-                        Session *s;
-                        User *u;
+        session = hashmap_get(m->session_units, unit);
+        if (session)
+                session_add_to_gc_queue(session);
 
-                        s = hashmap_get(m->session_units, unit);
-                        if (s)
-                                session_add_to_gc_queue(s);
+        user = hashmap_get(m->user_units, unit);
+        if (user)
+                user_add_to_gc_queue(user);
 
-                        u = hashmap_get(m->user_units, unit);
-                        if (u)
-                                user_add_to_gc_queue(u);
-                }
+        return 0;
+}
 
-        } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "UnitRemoved")) {
+int match_reloading(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Manager *m = userdata;
+        Session *session;
+        Iterator i;
+        int b, r;
 
-                const char *path, *unit;
-                Session *session;
-                User *user;
+        assert(bus);
 
-                if (!dbus_message_get_args(message, &error,
-                                           DBUS_TYPE_STRING, &unit,
-                                           DBUS_TYPE_OBJECT_PATH, &path,
-                                           DBUS_TYPE_INVALID)) {
-                        log_error("Failed to parse UnitRemoved message: %s", bus_error_message(&error));
-                        goto finish;
-                }
+        r = sd_bus_message_read(message, "b", &b);
+        if (r < 0) {
+                log_error("Failed to parse Reloading message: %s", strerror(-r));
+                return 0;
+        }
 
-                session = hashmap_get(m->session_units, unit);
-                if (session)
-                         session_add_to_gc_queue(session);
+        if (b)
+                return 0;
 
-                user = hashmap_get(m->user_units, unit);
-                if (user)
-                        user_add_to_gc_queue(user);
+        /* systemd finished reloading, let's recheck all our sessions */
+        log_debug("System manager has been reloaded, rechecking sessions...");
 
-        } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "Reloading")) {
-                dbus_bool_t b;
+        HASHMAP_FOREACH(session, m->sessions, i)
+                session_add_to_gc_queue(session);
 
-                if (!dbus_message_get_args(message, &error,
-                                           DBUS_TYPE_BOOLEAN, &b,
-                                           DBUS_TYPE_INVALID)) {
-                        log_error("Failed to parse Reloading message: %s", bus_error_message(&error));
-                        goto finish;
-                }
+        return 0;
+}
 
-                /* systemd finished reloading, let's recheck all our sessions */
-                if (!b) {
-                        Session *session;
-                        Iterator i;
+int match_name_owner_changed(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        const char *name, *old, *new;
+        Manager *m = userdata;
+        Session *session;
+        Iterator i;
+        int r;
 
-                        log_debug("System manager has been reloaded, rechecking sessions...");
 
-                        HASHMAP_FOREACH(session, m->sessions, i)
-                                session_add_to_gc_queue(session);
-                }
+        char *key;
 
-        } else if (dbus_message_is_signal(message, DBUS_INTERFACE_DBUS, "NameOwnerChanged")) {
-                const char *name, *old, *new;
-                char *key;
+        r = sd_bus_message_read(message, "sss", &name, &old, &new);
+        if (r < 0) {
+                log_error("Failed to parse NameOwnerChanged message: %s", strerror(-r));
+                return 0;
+        }
 
-                if (!dbus_message_get_args(message, &error,
-                                           DBUS_TYPE_STRING, &name,
-                                           DBUS_TYPE_STRING, &old,
-                                           DBUS_TYPE_STRING, &new,
-                                           DBUS_TYPE_INVALID)) {
-                        log_error("Failed to parse NameOwnerChanged message: %s", bus_error_message(&error));
-                        goto finish;
-                }
+        if (isempty(old) || !isempty(new))
+                return 0;
 
-                /* drop all controllers owned by this name */
-                if (*old && !*new && (key = hashmap_remove(m->busnames, old))) {
-                        Session *session;
-                        Iterator i;
+        key = set_remove(m->busnames, (char*) old);
+        if (!key)
+                return 0;
 
-                        free(key);
+        /* Drop all controllers owned by this name */
 
-                        HASHMAP_FOREACH(session, m->sessions, i)
-                                if (session_is_controller(session, old))
-                                        session_drop_controller(session);
-                }
-        }
+        free(key);
 
-finish:
-        dbus_error_free(&error);
+        HASHMAP_FOREACH(session, m->sessions, i)
+                if (session_is_controller(session, old))
+                        session_drop_controller(session);
 
-        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+        return 0;
 }
 
-int manager_send_changed(Manager *manager, const char *properties) {
-        _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
+int manager_send_changed(Manager *manager, const char *property, ...) {
+        char **l;
 
         assert(manager);
 
-        m = bus_properties_changed_new("/org/freedesktop/login1",
-                                       "org.freedesktop.login1.Manager",
-                                       properties);
-        if (!m)
-                return -ENOMEM;
-
-        if (!dbus_connection_send(manager->bus, m, NULL))
-                return -ENOMEM;
+        l = strv_from_stdarg_alloca(property);
 
-        return 0;
+        return sd_bus_emit_properties_changed_strv(
+                        manager->bus,
+                        "/org/freedesktop/login1",
+                        "org.freedesktop.login1.Manager",
+                        l);
 }
 
 int manager_dispatch_delayed(Manager *manager) {
-        DBusError error;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         int r;
 
         assert(manager);
@@ -2528,11 +2105,9 @@ int manager_dispatch_delayed(Manager *manager) {
         }
 
         /* Actually do the operation */
-        dbus_error_init(&error);
         r = execute_shutdown_or_sleep(manager, manager->action_what, manager->action_unit, &error);
         if (r < 0) {
-                log_warning("Failed to send delayed message: %s", bus_error(&error, r));
-                dbus_error_free(&error);
+                log_warning("Failed to send delayed message: %s", bus_error_message(&error, r));
 
                 manager->action_unit = NULL;
                 manager->action_what = 0;
@@ -2550,87 +2125,56 @@ int manager_start_scope(
                 const char *description,
                 const char *after,
                 const char *kill_mode,
-                DBusError *error,
+                sd_bus_error *error,
                 char **job) {
 
-        const char *timeout_stop_property = "TimeoutStopUSec", *send_sighup_property = "SendSIGHUP", *pids_property = "PIDs";
-        _cleanup_dbus_message_unref_ DBusMessage *m = NULL, *reply = NULL;
-        DBusMessageIter iter, sub, sub2, sub3, sub4;
-        uint64_t timeout = 500 * USEC_PER_MSEC;
-        dbus_bool_t send_sighup = true;
-        const char *fail = "fail";
-        uint32_t u;
+        _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *reply = NULL;
+        int r;
 
         assert(manager);
         assert(scope);
         assert(pid > 1);
 
-        if (!slice)
-                slice = "";
-
-        m = dbus_message_new_method_call(
+        r = sd_bus_message_new_method_call(
+                        manager->bus,
                         "org.freedesktop.systemd1",
                         "/org/freedesktop/systemd1",
                         "org.freedesktop.systemd1.Manager",
-                        "StartTransientUnit");
-        if (!m)
-                return log_oom();
+                        "StartTransientUnit",
+                        &m);
+        if (r < 0)
+                return r;
 
-        dbus_message_iter_init_append(m, &iter);
+        r = sd_bus_message_append(m, "ss", strempty(scope), "fail");
+        if (r < 0)
+                return r;
 
-        if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &scope) ||
-            !dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &fail) ||
-            !dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(sv)", &sub))
-                return log_oom();
+        r = sd_bus_message_open_container(m, 'a', "(sv)");
+        if (r < 0)
+                return r;
 
         if (!isempty(slice)) {
-                const char *slice_property = "Slice";
-
-                if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
-                    !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &slice_property) ||
-                    !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "s", &sub3) ||
-                    !dbus_message_iter_append_basic(&sub3, DBUS_TYPE_STRING, &slice) ||
-                    !dbus_message_iter_close_container(&sub2, &sub3) ||
-                    !dbus_message_iter_close_container(&sub, &sub2))
-                        return log_oom();
+                r = sd_bus_message_append(m, "(sv)", "Slice", "s", slice);
+                if (r < 0)
+                        return r;
         }
 
         if (!isempty(description)) {
-                const char *description_property = "Description";
-
-                if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
-                    !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &description_property) ||
-                    !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "s", &sub3) ||
-                    !dbus_message_iter_append_basic(&sub3, DBUS_TYPE_STRING, &description) ||
-                    !dbus_message_iter_close_container(&sub2, &sub3) ||
-                    !dbus_message_iter_close_container(&sub, &sub2))
-                        return log_oom();
+                r = sd_bus_message_append(m, "(sv)", "Description", "s", description);
+                if (r < 0)
+                        return r;
         }
 
-        if (!isempty(after)) {
-                const char *after_property = "After";
-
-                if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
-                    !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &after_property) ||
-                    !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "as", &sub3) ||
-                    !dbus_message_iter_open_container(&sub3, DBUS_TYPE_ARRAY, "s", &sub4) ||
-                    !dbus_message_iter_append_basic(&sub4, DBUS_TYPE_STRING, &after) ||
-                    !dbus_message_iter_close_container(&sub3, &sub4) ||
-                    !dbus_message_iter_close_container(&sub2, &sub3) ||
-                    !dbus_message_iter_close_container(&sub, &sub2))
-                        return log_oom();
+        if (!isempty(description)) {
+                r = sd_bus_message_append(m, "(sv)", "After", "as", 1, after);
+                if (r < 0)
+                        return r;
         }
 
         if (!isempty(kill_mode)) {
-                const char *kill_mode_property = "KillMode";
-
-                if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
-                    !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &kill_mode_property) ||
-                    !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "s", &sub3) ||
-                    !dbus_message_iter_append_basic(&sub3, DBUS_TYPE_STRING, &kill_mode) ||
-                    !dbus_message_iter_close_container(&sub2, &sub3) ||
-                    !dbus_message_iter_close_container(&sub, &sub2))
-                        return log_oom();
+                r = sd_bus_message_append(m, "(sv)", "KillMode", "s", kill_mode);
+                if (r < 0)
+                        return r;
         }
 
         /* cgroup empty notification is not available in containers
@@ -2638,48 +2182,35 @@ int manager_start_scope(
          * stop timeout for sessions, so that we don't wait
          * forever. */
 
-        if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
-            !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &timeout_stop_property) ||
-            !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "t", &sub3) ||
-            !dbus_message_iter_append_basic(&sub3, DBUS_TYPE_UINT64, &timeout) ||
-            !dbus_message_iter_close_container(&sub2, &sub3) ||
-            !dbus_message_iter_close_container(&sub, &sub2))
-                return log_oom();
+        r = sd_bus_message_append(m, "(sv)", "TimeoutStopUSec", "t", 500 * USEC_PER_MSEC);
+        if (r < 0)
+                return r;
 
         /* Make sure that the session shells are terminated with
          * SIGHUP since bash and friends tend to ignore SIGTERM */
-        if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
-            !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &send_sighup_property) ||
-            !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "b", &sub3) ||
-            !dbus_message_iter_append_basic(&sub3, DBUS_TYPE_BOOLEAN, &send_sighup) ||
-            !dbus_message_iter_close_container(&sub2, &sub3) ||
-            !dbus_message_iter_close_container(&sub, &sub2))
-                return log_oom();
-
-        u = pid;
-        if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
-            !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &pids_property) ||
-            !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "au", &sub3) ||
-            !dbus_message_iter_open_container(&sub3, DBUS_TYPE_ARRAY, "u", &sub4) ||
-            !dbus_message_iter_append_basic(&sub4, DBUS_TYPE_UINT32, &u) ||
-            !dbus_message_iter_close_container(&sub3, &sub4) ||
-            !dbus_message_iter_close_container(&sub2, &sub3) ||
-            !dbus_message_iter_close_container(&sub, &sub2))
-                return log_oom();
-
-        if (!dbus_message_iter_close_container(&iter, &sub))
-                return log_oom();
-
-        reply = dbus_connection_send_with_reply_and_block(manager->bus, m, -1, error);
-        if (!reply)
-                return -EIO;
+        r = sd_bus_message_append(m, "(sv)", "SendSIGHUP", "b", true);
+        if (r < 0)
+                return r;
+
+        r = sd_bus_message_append(m, "(sv)", "PIDs", "au", 1, pid);
+        if (r < 0)
+                return r;
+
+        r = sd_bus_message_close_container(m);
+        if (r < 0)
+                return r;
+
+        r = sd_bus_send_with_reply_and_block(manager->bus, m, 0, error, &reply);
+        if (r < 0)
+                return r;
 
         if (job) {
                 const char *j;
                 char *copy;
 
-                if (!dbus_message_get_args(reply, error, DBUS_TYPE_OBJECT_PATH, &j, DBUS_TYPE_INVALID))
-                        return -EIO;
+                r = sd_bus_message_read(reply, "o", &j);
+                if (r < 0)
+                        return r;
 
                 copy = strdup(j);
                 if (!copy)
@@ -2688,43 +2219,35 @@ int manager_start_scope(
                 *job = copy;
         }
 
-        return 0;
+        return 1;
 }
 
-int manager_start_unit(Manager *manager, const char *unit, DBusError *error, char **job) {
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
-        const char *fail = "fail";
+int manager_start_unit(Manager *manager, const char *unit, sd_bus_error *error, char **job) {
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
         int r;
 
         assert(manager);
         assert(unit);
 
-        r = bus_method_call_with_reply(
+        r = sd_bus_call_method(
                         manager->bus,
                         "org.freedesktop.systemd1",
                         "/org/freedesktop/systemd1",
                         "org.freedesktop.systemd1.Manager",
                         "StartUnit",
-                        &reply,
                         error,
-                        DBUS_TYPE_STRING, &unit,
-                        DBUS_TYPE_STRING, &fail,
-                        DBUS_TYPE_INVALID);
-        if (r < 0) {
-                log_error("Failed to start unit %s: %s", unit, bus_error(error, r));
+                        &reply,
+                        "ss", unit, "fail");
+        if (r < 0)
                 return r;
-        }
 
         if (job) {
                 const char *j;
                 char *copy;
 
-                if (!dbus_message_get_args(reply, error,
-                                           DBUS_TYPE_OBJECT_PATH, &j,
-                                           DBUS_TYPE_INVALID)) {
-                        log_error("Failed to parse reply.");
-                        return -EIO;
-                }
+                r = sd_bus_message_read(reply, "o", &j);
+                if (r < 0)
+                        return r;
 
                 copy = strdup(j);
                 if (!copy)
@@ -2733,40 +2256,36 @@ int manager_start_unit(Manager *manager, const char *unit, DBusError *error, cha
                 *job = copy;
         }
 
-        return 0;
+        return 1;
 }
 
-int manager_stop_unit(Manager *manager, const char *unit, DBusError *error, char **job) {
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
-        const char *fail = "fail";
+int manager_stop_unit(Manager *manager, const char *unit, sd_bus_error *error, char **job) {
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
         int r;
 
         assert(manager);
         assert(unit);
 
-        r = bus_method_call_with_reply(
+        r = sd_bus_call_method(
                         manager->bus,
                         "org.freedesktop.systemd1",
                         "/org/freedesktop/systemd1",
                         "org.freedesktop.systemd1.Manager",
                         "StopUnit",
-                        &reply,
                         error,
-                        DBUS_TYPE_STRING, &unit,
-                        DBUS_TYPE_STRING, &fail,
-                        DBUS_TYPE_INVALID);
+                        &reply,
+                        "ss", unit, "fail");
         if (r < 0) {
-                if (dbus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT) ||
-                    dbus_error_has_name(error, BUS_ERROR_LOAD_FAILED)) {
+                if (sd_bus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT) ||
+                    sd_bus_error_has_name(error, BUS_ERROR_LOAD_FAILED)) {
 
                         if (job)
                                 *job = NULL;
 
-                        dbus_error_free(error);
+                        sd_bus_error_free(error);
                         return 0;
                 }
 
-                log_error("Failed to stop unit %s: %s", unit, bus_error(error, r));
                 return r;
         }
 
@@ -2774,12 +2293,9 @@ int manager_stop_unit(Manager *manager, const char *unit, DBusError *error, char
                 const char *j;
                 char *copy;
 
-                if (!dbus_message_get_args(reply, error,
-                                           DBUS_TYPE_OBJECT_PATH, &j,
-                                           DBUS_TYPE_INVALID)) {
-                        log_error("Failed to parse reply.");
-                        return -EIO;
-                }
+                r = sd_bus_message_read(reply, "o", &j);
+                if (r < 0)
+                        return r;
 
                 copy = strdup(j);
                 if (!copy)
@@ -2791,106 +2307,97 @@ int manager_stop_unit(Manager *manager, const char *unit, DBusError *error, char
         return 1;
 }
 
-int manager_kill_unit(Manager *manager, const char *unit, KillWho who, int signo, DBusError *error) {
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
-        const char *w;
-        int r;
-
+int manager_kill_unit(Manager *manager, const char *unit, KillWho who, int signo, sd_bus_error *error) {
         assert(manager);
         assert(unit);
 
-        w = who == KILL_LEADER ? "process" : "cgroup";
-        assert_cc(sizeof(signo) == sizeof(int32_t));
-
-        r = bus_method_call_with_reply(
+        return sd_bus_call_method(
                         manager->bus,
                         "org.freedesktop.systemd1",
                         "/org/freedesktop/systemd1",
                         "org.freedesktop.systemd1.Manager",
                         "KillUnit",
-                        &reply,
                         error,
-                        DBUS_TYPE_STRING, &unit,
-                        DBUS_TYPE_STRING, &w,
-                        DBUS_TYPE_INT32, &signo,
-                        DBUS_TYPE_INVALID);
-        if (r < 0) {
-                log_error("Failed to stop unit %s: %s", unit, bus_error(error, r));
-                return r;
-        }
-
-        return 0;
+                        NULL,
+                        "ssi", unit, who == KILL_LEADER ? "main" : "all", signo);
 }
 
 int manager_unit_is_active(Manager *manager, const char *unit) {
-
-        const char *interface = "org.freedesktop.systemd1.Unit";
-        const char *property = "ActiveState";
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
         _cleanup_free_ char *path = NULL;
-        DBusMessageIter iter, sub;
         const char *state;
-        DBusError error;
         int r;
 
         assert(manager);
         assert(unit);
 
-        dbus_error_init(&error);
-
         path = unit_dbus_path_from_name(unit);
         if (!path)
                 return -ENOMEM;
 
-        r = bus_method_call_with_reply(
+        r = sd_bus_get_property(
                         manager->bus,
                         "org.freedesktop.systemd1",
                         path,
-                        "org.freedesktop.DBus.Properties",
-                        "Get",
-                        &reply,
+                        "org.freedesktop.systemd1.Unit",
+                        "ActiveState",
                         &error,
-                        DBUS_TYPE_STRING, &interface,
-                        DBUS_TYPE_STRING, &property,
-                        DBUS_TYPE_INVALID);
+                        &reply,
+                        "s");
         if (r < 0) {
-                if (dbus_error_has_name(&error, DBUS_ERROR_NO_REPLY) ||
-                    dbus_error_has_name(&error, DBUS_ERROR_DISCONNECTED)) {
-                        /* systemd might have droppped off
-                         * momentarily, let's not make this an
-                         * error */
-
-                        dbus_error_free(&error);
+                /* systemd might have droppped off momentarily, let's
+                 * not make this an error */
+                if (sd_bus_error_has_name(&error, SD_BUS_ERROR_NO_REPLY) ||
+                    sd_bus_error_has_name(&error, SD_BUS_ERROR_DISCONNECTED))
                         return true;
-                }
-
-                if (dbus_error_has_name(&error, BUS_ERROR_NO_SUCH_UNIT) ||
-                    dbus_error_has_name(&error, BUS_ERROR_LOAD_FAILED)) {
-                        /* If the unit is already unloaded then it's
-                         * not active */
 
-                        dbus_error_free(&error);
+                /* If the unit is already unloaded then it's not
+                 * active */
+                if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_UNIT) ||
+                    sd_bus_error_has_name(&error, BUS_ERROR_LOAD_FAILED))
                         return false;
-                }
 
-                log_error("Failed to query ActiveState: %s", bus_error(&error, r));
-                dbus_error_free(&error);
                 return r;
         }
 
-        if (!dbus_message_iter_init(reply, &iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {
-                log_error("Failed to parse reply.");
+        r = sd_bus_message_read(reply, "s", &state);
+        if (r < 0)
                 return -EINVAL;
-        }
 
-        dbus_message_iter_recurse(&iter, &sub);
-        if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING) {
-                log_error("Failed to parse reply.");
-                return -EINVAL;
+        return !streq(state, "inactive") && !streq(state, "failed");
+}
+
+int manager_job_is_active(Manager *manager, const char *path) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        int r;
+
+        assert(manager);
+        assert(path);
+
+        r = sd_bus_get_property(
+                        manager->bus,
+                        "org.freedesktop.systemd1",
+                        path,
+                        "org.freedesktop.systemd1.Job",
+                        "State",
+                        &error,
+                        &reply,
+                        "s");
+        if (r < 0) {
+                if (sd_bus_error_has_name(&error, SD_BUS_ERROR_NO_REPLY) ||
+                    sd_bus_error_has_name(&error, SD_BUS_ERROR_DISCONNECTED))
+                        return true;
+
+                if (sd_bus_error_has_name(&error, SD_BUS_ERROR_UNKNOWN_OBJECT))
+                        return false;
+
+                return r;
         }
 
-        dbus_message_iter_get_basic(&sub, &state);
+        /* We don't actually care about the state really. The fact
+         * that we could read the job state is enough for us */
 
-        return !streq(state, "inactive") && !streq(state, "failed");
+        return true;
 }
diff --git a/src/login/logind-device.c b/src/login/logind-device.c
index 9ff91ba03..c5fe92bd6 100644
--- a/src/login/logind-device.c
+++ b/src/login/logind-device.c
@@ -22,8 +22,8 @@
 #include <assert.h>
 #include <string.h>
 
-#include "logind-device.h"
 #include "util.h"
+#include "logind-device.h"
 
 Device* device_new(Manager *m, const char *sysfs, bool master) {
         Device *d;
@@ -68,6 +68,7 @@ void device_free(Device *d) {
 void device_detach(Device *d) {
         Seat *s;
         SessionDevice *sd;
+
         assert(d);
 
         if (!d->seat)
@@ -82,7 +83,7 @@ void device_detach(Device *d) {
 
         if (!seat_has_master_device(s)) {
                 seat_add_to_gc_queue(s);
-                seat_send_changed(s, "CanGraphical\0");
+                seat_send_changed(s, "CanGraphical", NULL);
         }
 }
 
@@ -121,5 +122,5 @@ void device_attach(Device *d, Seat *s) {
         }
 
         if (!had_master && d->master)
-                seat_send_changed(s, "CanGraphical\0");
+                seat_send_changed(s, "CanGraphical", NULL);
 }
diff --git a/src/login/logind-inhibit.c b/src/login/logind-inhibit.c
index e77088364..3bc464207 100644
--- a/src/login/logind-inhibit.c
+++ b/src/login/logind-inhibit.c
@@ -21,7 +21,6 @@
 
 #include <errno.h>
 #include <fcntl.h>
-#include <sys/epoll.h>
 #include <string.h>
 #include <errno.h>
 #include <unistd.h>
@@ -64,12 +63,13 @@ Inhibitor* inhibitor_new(Manager *m, const char* id) {
 void inhibitor_free(Inhibitor *i) {
         assert(i);
 
-        free(i->who);
-        free(i->why);
-
         hashmap_remove(i->manager->inhibitors, i->id);
+
         inhibitor_remove_fifo(i);
 
+        free(i->who);
+        free(i->why);
+
         if (i->state_file) {
                 unlink(i->state_file);
                 free(i->state_file);
@@ -79,9 +79,9 @@ void inhibitor_free(Inhibitor *i) {
 }
 
 int inhibitor_save(Inhibitor *i) {
-        char *temp_path, *cc;
+        _cleanup_free_ char *temp_path = NULL;
+        _cleanup_fclose_ FILE *f = NULL;
         int r;
-        FILE *f;
 
         assert(i);
 
@@ -107,23 +107,23 @@ int inhibitor_save(Inhibitor *i) {
                 (unsigned long) i->pid);
 
         if (i->who) {
+                _cleanup_free_ char *cc = NULL;
+
                 cc = cescape(i->who);
                 if (!cc)
                         r = -ENOMEM;
-                else {
+                else
                         fprintf(f, "WHO=%s\n", cc);
-                        free(cc);
-                }
         }
 
         if (i->why) {
+                _cleanup_free_ char *cc = NULL;
+
                 cc = cescape(i->why);
                 if (!cc)
                         r = -ENOMEM;
-                else {
+                else
                         fprintf(f, "WHY=%s\n", cc);
-                        free(cc);
-                }
         }
 
         if (i->fifo_path)
@@ -137,9 +137,6 @@ int inhibitor_save(Inhibitor *i) {
                 unlink(temp_path);
         }
 
-        fclose(f);
-        free(temp_path);
-
 finish:
         if (r < 0)
                 log_error("Failed to save inhibit data for %s: %s", i->id, strerror(-r));
@@ -164,7 +161,7 @@ int inhibitor_start(Inhibitor *i) {
 
         i->started = true;
 
-        manager_send_changed(i->manager, i->mode == INHIBIT_BLOCK ? "BlockInhibited\0" : "DelayInhibited\0");
+        manager_send_changed(i->manager, i->mode == INHIBIT_BLOCK ? "BlockInhibited" : "DelayInhibited", NULL);
 
         return 0;
 }
@@ -183,16 +180,14 @@ int inhibitor_stop(Inhibitor *i) {
 
         i->started = false;
 
-        manager_send_changed(i->manager, i->mode == INHIBIT_BLOCK ? "BlockInhibited\0" : "DelayInhibited\0");
+        manager_send_changed(i->manager, i->mode == INHIBIT_BLOCK ? "BlockInhibited" : "DelayInhibited", NULL);
 
         return 0;
 }
 
 int inhibitor_load(Inhibitor *i) {
-        InhibitWhat w;
-        InhibitMode mm;
-        int r;
-        char *cc,
+
+        _cleanup_free_ char
                 *what = NULL,
                 *uid = NULL,
                 *pid = NULL,
@@ -200,6 +195,11 @@ int inhibitor_load(Inhibitor *i) {
                 *why = NULL,
                 *mode = NULL;
 
+        InhibitWhat w;
+        InhibitMode mm;
+        char *cc;
+        int r;
+
         r = parse_env_file(i->state_file, NEWLINE,
                            "WHAT", &what,
                            "UID", &uid,
@@ -210,7 +210,7 @@ int inhibitor_load(Inhibitor *i) {
                            "FIFO", &i->fifo_path,
                            NULL);
         if (r < 0)
-                goto finish;
+                return r;
 
         w = what ? inhibit_what_from_string(what) : 0;
         if (w >= 0)
@@ -223,21 +223,19 @@ int inhibitor_load(Inhibitor *i) {
         if (uid) {
                 r = parse_uid(uid, &i->uid);
                 if (r < 0)
-                        goto finish;
+                        return r;
         }
 
         if (pid) {
                 r = parse_pid(pid, &i->pid);
                 if (r < 0)
-                        goto finish;
+                        return r;
         }
 
         if (who) {
                 cc = cunescape(who);
-                if (!cc) {
-                        r = -ENOMEM;
-                        goto finish;
-                }
+                if (!cc)
+                        return -ENOMEM;
 
                 free(i->who);
                 i->who = cc;
@@ -245,10 +243,8 @@ int inhibitor_load(Inhibitor *i) {
 
         if (why) {
                 cc = cunescape(why);
-                if (!cc) {
-                        r = -ENOMEM;
-                        goto finish;
-                }
+                if (!cc)
+                        return -ENOMEM;
 
                 free(i->why);
                 i->why = cc;
@@ -262,14 +258,20 @@ int inhibitor_load(Inhibitor *i) {
                         close_nointr_nofail(fd);
         }
 
-finish:
-        free(what);
-        free(uid);
-        free(pid);
-        free(who);
-        free(why);
+        return 0;
+}
 
-        return r;
+static int inhibitor_dispatch_fifo(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
+        Inhibitor *i = userdata;
+
+        assert(s);
+        assert(fd == i->fifo_fd);
+        assert(i);
+
+        inhibitor_stop(i);
+        inhibitor_free(i);
+
+        return 0;
 }
 
 int inhibitor_create_fifo(Inhibitor *i) {
@@ -283,7 +285,8 @@ int inhibitor_create_fifo(Inhibitor *i) {
                 if (r < 0)
                         return r;
 
-                if (asprintf(&i->fifo_path, "/run/systemd/inhibit/%s.ref", i->id) < 0)
+                i->fifo_path = strjoin("/run/systemd/inhibit/", i->id, ".ref", NULL);
+                if (!i->fifo_path)
                         return -ENOMEM;
 
                 if (mkfifo(i->fifo_path, 0600) < 0 && errno != EEXIST)
@@ -292,21 +295,19 @@ int inhibitor_create_fifo(Inhibitor *i) {
 
         /* Open reading side */
         if (i->fifo_fd < 0) {
-                struct epoll_event ev = {};
-
                 i->fifo_fd = open(i->fifo_path, O_RDONLY|O_CLOEXEC|O_NDELAY);
                 if (i->fifo_fd < 0)
                         return -errno;
+        }
 
-                r = hashmap_put(i->manager->inhibitor_fds, INT_TO_PTR(i->fifo_fd + 1), i);
+        if (!i->event_source) {
+                r = sd_event_add_io(i->manager->event, i->fifo_fd, 0, inhibitor_dispatch_fifo, i, &i->event_source);
                 if (r < 0)
                         return r;
 
-                ev.events = 0;
-                ev.data.u32 = FD_OTHER_BASE + i->fifo_fd;
-
-                if (epoll_ctl(i->manager->epoll_fd, EPOLL_CTL_ADD, i->fifo_fd, &ev) < 0)
-                        return -errno;
+                r = sd_event_source_set_priority(i->event_source, SD_PRIORITY_IDLE);
+                if (r < 0)
+                        return r;
         }
 
         /* Open writing side */
@@ -320,9 +321,10 @@ int inhibitor_create_fifo(Inhibitor *i) {
 void inhibitor_remove_fifo(Inhibitor *i) {
         assert(i);
 
+        if (i->event_source)
+                i->event_source = sd_event_source_unref(i->event_source);
+
         if (i->fifo_fd >= 0) {
-                assert_se(hashmap_remove(i->manager->inhibitor_fds, INT_TO_PTR(i->fifo_fd + 1)) == i);
-                assert_se(epoll_ctl(i->manager->epoll_fd, EPOLL_CTL_DEL, i->fifo_fd, NULL) == 0);
                 close_nointr_nofail(i->fifo_fd);
                 i->fifo_fd = -1;
         }
@@ -341,7 +343,7 @@ InhibitWhat manager_inhibit_what(Manager *m, InhibitMode mm) {
 
         assert(m);
 
-        HASHMAP_FOREACH(i, m->inhibitor_fds, j)
+        HASHMAP_FOREACH(i, m->inhibitors, j)
                 if (i->mode == mm)
                         what |= i->what;
 
@@ -381,7 +383,7 @@ bool manager_is_inhibited(
         assert(m);
         assert(w > 0 && w < _INHIBIT_WHAT_MAX);
 
-        HASHMAP_FOREACH(i, m->inhibitor_fds, j) {
+        HASHMAP_FOREACH(i, m->inhibitors, j) {
                 if (!(i->what & w))
                         continue;
 
diff --git a/src/login/logind-inhibit.h b/src/login/logind-inhibit.h
index 4c158ee0f..ed3b2ebcc 100644
--- a/src/login/logind-inhibit.h
+++ b/src/login/logind-inhibit.h
@@ -52,6 +52,8 @@ typedef enum InhibitMode {
 struct Inhibitor {
         Manager *manager;
 
+        sd_event_source *event_source;
+
         char *id;
         char *state_file;
 
diff --git a/src/login/logind-seat-dbus.c b/src/login/logind-seat-dbus.c
index 230f7f082..e9f8d2637 100644
--- a/src/login/logind-seat-dbus.c
+++ b/src/login/logind-seat-dbus.c
@@ -22,373 +22,328 @@
 #include <errno.h>
 #include <string.h>
 
+#include "util.h"
+#include "bus-util.h"
+#include "strv.h"
 #include "logind.h"
 #include "logind-seat.h"
-#include "dbus-common.h"
-#include "util.h"
 
-#define BUS_SEAT_INTERFACE \
-        " <interface name=\"org.freedesktop.login1.Seat\">\n"           \
-        "  <method name=\"Terminate\"/>\n"                              \
-        "  <method name=\"ActivateSession\">\n"                         \
-        "   <arg name=\"id\" type=\"s\"/>\n"                            \
-        "  </method>\n"                                                 \
-        "  <property name=\"Id\" type=\"s\" access=\"read\"/>\n"        \
-        "  <property name=\"ActiveSession\" type=\"so\" access=\"read\"/>\n" \
-        "  <property name=\"CanMultiSession\" type=\"b\" access=\"read\"/>\n" \
-        "  <property name=\"CanTTY\" type=\"b\" access=\"read\"/>\n" \
-        "  <property name=\"CanGraphical\" type=\"b\" access=\"read\"/>\n" \
-        "  <property name=\"Sessions\" type=\"a(so)\" access=\"read\"/>\n" \
-        "  <property name=\"IdleHint\" type=\"b\" access=\"read\"/>\n"  \
-        "  <property name=\"IdleSinceHint\" type=\"t\" access=\"read\"/>\n" \
-        "  <property name=\"IdleSinceHintMonotonic\" type=\"t\" access=\"read\"/>\n" \
-        " </interface>\n"                                               \
-
-#define INTROSPECTION                                                   \
-        DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE                       \
-        "<node>\n"                                                      \
-        BUS_SEAT_INTERFACE                                              \
-        BUS_PROPERTIES_INTERFACE                                        \
-        BUS_PEER_INTERFACE                                              \
-        BUS_INTROSPECTABLE_INTERFACE                                    \
-        "</node>\n"
-
-#define INTERFACES_LIST                              \
-        BUS_GENERIC_INTERFACES_LIST                  \
-        "org.freedesktop.login1.Seat\0"
-
-static int bus_seat_append_active(DBusMessageIter *i, const char *property, void *data) {
-        DBusMessageIter sub;
-        Seat *s = data;
-        const char *id, *path;
+static int property_get_active_session(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                sd_bus_error *error,
+                void *userdata) {
+
         _cleanup_free_ char *p = NULL;
+        Seat *s = userdata;
 
-        assert(i);
-        assert(property);
+        assert(bus);
+        assert(reply);
         assert(s);
 
-        if (!dbus_message_iter_open_container(i, DBUS_TYPE_STRUCT, NULL, &sub))
+        p = s->active ? session_bus_path(s->active) : strdup("/");
+        if (!p)
                 return -ENOMEM;
 
-        if (s->active) {
-                id = s->active->id;
-                path = p = session_bus_path(s->active);
+        return sd_bus_message_append(reply, "(so)", s->active ? s->active->id : "", p);
+}
 
-                if (!p)
-                        return -ENOMEM;
-        } else {
-                id = "";
-                path = "/";
-        }
+static int property_get_can_multi_session(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                sd_bus_error *error,
+                void *userdata) {
 
-        if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &id) ||
-            !dbus_message_iter_append_basic(&sub, DBUS_TYPE_OBJECT_PATH, &path))
-                return -ENOMEM;
+        Seat *s = userdata;
 
-        if (!dbus_message_iter_close_container(i, &sub))
-                return -ENOMEM;
+        assert(bus);
+        assert(reply);
+        assert(s);
 
-        return 0;
+        return sd_bus_message_append(reply, "b", seat_can_multi_session(s));
 }
 
-static int bus_seat_append_sessions(DBusMessageIter *i, const char *property, void *data) {
-        DBusMessageIter sub, sub2;
-        Seat *s = data;
+static int property_get_can_tty(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                sd_bus_error *error,
+                void *userdata) {
+
+        Seat *s = userdata;
+
+        assert(bus);
+        assert(reply);
+        assert(s);
+
+        return sd_bus_message_append(reply, "b", seat_can_tty(s));
+}
+
+static int property_get_can_graphical(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                sd_bus_error *error,
+                void *userdata) {
+
+        Seat *s = userdata;
+
+        assert(bus);
+        assert(reply);
+        assert(s);
+
+        return sd_bus_message_append(reply, "b", seat_can_tty(s));
+}
+
+static int property_get_sessions(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                sd_bus_error *error,
+                void *userdata) {
+
+        Seat *s = userdata;
         Session *session;
+        int r;
 
-        assert(i);
-        assert(property);
+        assert(bus);
+        assert(reply);
         assert(s);
 
-        if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "(so)", &sub))
-                return -ENOMEM;
+        r = sd_bus_message_open_container(reply, 'a', "(so)");
+        if (r < 0)
+                return r;
 
         LIST_FOREACH(sessions_by_seat, session, s->sessions) {
                 _cleanup_free_ char *p = NULL;
 
-                if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
-                        return -ENOMEM;
-
                 p = session_bus_path(session);
                 if (!p)
                         return -ENOMEM;
 
-                if (!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &session->id) ||
-                    !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_OBJECT_PATH, &p))
-                        return -ENOMEM;
+                r = sd_bus_message_append(reply, "(so)", session->id, p);
+                if (r < 0)
+                        return r;
 
-                if (!dbus_message_iter_close_container(&sub, &sub2))
-                        return -ENOMEM;
         }
 
-        if (!dbus_message_iter_close_container(i, &sub))
-                return -ENOMEM;
+        r = sd_bus_message_close_container(reply);
+        if (r < 0)
+                return r;
 
-        return 0;
+        return 1;
 }
 
-static int bus_seat_append_can_multi_session(DBusMessageIter *i, const char *property, void *data) {
-        Seat *s = data;
-        dbus_bool_t b;
-
-        assert(i);
-        assert(property);
-        assert(s);
-
-        b = seat_can_multi_session(s);
-
-        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
-                return -ENOMEM;
-
-        return 0;
-}
+static int property_get_idle_hint(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                sd_bus_error *error,
+                void *userdata) {
 
-static int bus_seat_append_can_tty(DBusMessageIter *i, const char *property, void *data) {
-        Seat *s = data;
-        dbus_bool_t b;
+        Seat *s = userdata;
 
-        assert(i);
-        assert(property);
+        assert(bus);
+        assert(reply);
         assert(s);
 
-        b = seat_can_tty(s);
-
-        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
-                return -ENOMEM;
-
-        return 0;
+        return sd_bus_message_append(reply, "b", seat_get_idle_hint(s, NULL) > 0);
 }
 
-static int bus_seat_append_can_graphical(DBusMessageIter *i, const char *property, void *data) {
-        Seat *s = data;
-        dbus_bool_t b;
+static int property_get_idle_since_hint(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                sd_bus_error *error,
+                void *userdata) {
+
+        Seat *s = userdata;
+        dual_timestamp t;
+        uint64_t u;
+        int r;
 
-        assert(i);
-        assert(property);
+        assert(bus);
+        assert(reply);
         assert(s);
 
-        b = seat_can_graphical(s);
+        r = seat_get_idle_hint(s, &t);
+        if (r < 0)
+                return r;
 
-        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
-                return -ENOMEM;
+        u = streq(property, "IdleSinceHint") ? t.realtime : t.monotonic;
 
-        return 0;
+        return sd_bus_message_append(reply, "t", u);
 }
 
-static int bus_seat_append_idle_hint(DBusMessageIter *i, const char *property, void *data) {
-        Seat *s = data;
-        dbus_bool_t b;
+static int method_terminate(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Seat *s = userdata;
+        int r;
 
-        assert(i);
-        assert(property);
+        assert(bus);
+        assert(message);
         assert(s);
 
-        b = seat_get_idle_hint(s, NULL) > 0;
-        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
-                return -ENOMEM;
+        r = seat_stop_sessions(s);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-        return 0;
+        return sd_bus_reply_method_return(bus, message, NULL);
 }
 
-static int bus_seat_append_idle_hint_since(DBusMessageIter *i, const char *property, void *data) {
-        Seat *s = data;
-        dual_timestamp t;
-        uint64_t k;
+static int method_activate_session(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Seat *s = userdata;
+        const char *name;
+        Session *session;
+        int r;
 
-        assert(i);
-        assert(property);
+        assert(bus);
+        assert(message);
         assert(s);
 
-        seat_get_idle_hint(s, &t);
-        k = streq(property, "IdleSinceHint") ? t.realtime : t.monotonic;
+        r = sd_bus_message_read(message, "s", &name);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, &k))
-                return -ENOMEM;
+        session = hashmap_get(s->manager->sessions, name);
+        if (!session)
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", name);
 
-        return 0;
-}
+        if (session->seat != s)
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_SESSION_NOT_ON_SEAT, "Session %s not on seat %s", name, s->id);
 
-static int get_seat_for_path(Manager *m, const char *path, Seat **_s) {
-        _cleanup_free_ char *id = NULL;
-        Seat *s;
+        r = session_activate(session);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-        assert(m);
-        assert(path);
-        assert(_s);
-
-        if (!startswith(path, "/org/freedesktop/login1/seat/"))
-                return -EINVAL;
-
-        id = bus_path_unescape(path + 29);
-        if (!id)
-                return -ENOMEM;
-
-        s = hashmap_get(m->seats, id);
-        if (!s)
-                return -ENOENT;
-
-        *_s = s;
-        return 0;
+        return sd_bus_reply_method_return(bus, message, NULL);
 }
 
-static const BusProperty bus_login_seat_properties[] = {
-        { "Id",                     bus_property_append_string,      "s", offsetof(Seat, id), true },
-        { "ActiveSession",          bus_seat_append_active,       "(so)", 0 },
-        { "CanMultiSession",        bus_seat_append_can_multi_session, "b", 0 },
-        { "CanTTY",                 bus_seat_append_can_tty,         "b", 0 },
-        { "CanGraphical",           bus_seat_append_can_graphical,   "b", 0 },
-        { "Sessions",               bus_seat_append_sessions,    "a(so)", 0 },
-        { "IdleHint",               bus_seat_append_idle_hint,       "b", 0 },
-        { "IdleSinceHint",          bus_seat_append_idle_hint_since, "t", 0 },
-        { "IdleSinceHintMonotonic", bus_seat_append_idle_hint_since, "t", 0 },
-        { NULL, }
-};
-
-static DBusHandlerResult seat_message_dispatch(
-                Seat *s,
-                DBusConnection *connection,
-                DBusMessage *message) {
-
-        DBusError error;
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
-        int r;
+const sd_bus_vtable seat_vtable[] = {
+        SD_BUS_VTABLE_START(0),
 
-        assert(s);
-        assert(connection);
-        assert(message);
+        SD_BUS_PROPERTY("Id", "s", NULL, offsetof(Seat, id), 0),
+        SD_BUS_PROPERTY("ActiveSession", "(so)", property_get_active_session, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+        SD_BUS_PROPERTY("CanMultiSession", "b", property_get_can_multi_session, 0, 0),
+        SD_BUS_PROPERTY("CanTTY", "b", property_get_can_tty, 0, 0),
+        SD_BUS_PROPERTY("CanGraphical", "b", property_get_can_graphical, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+        SD_BUS_PROPERTY("Sessions", "a(so)", property_get_sessions, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+        SD_BUS_PROPERTY("IdleHint", "b", property_get_idle_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+        SD_BUS_PROPERTY("IdleSinceHint", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+        SD_BUS_PROPERTY("IdleSinceHintMonotonic", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 
-        dbus_error_init(&error);
+        SD_BUS_METHOD("Terminate", NULL, NULL, method_terminate, 0),
+        SD_BUS_METHOD("ActivateSession", "s", NULL, method_activate_session, 0),
 
-        if (dbus_message_is_method_call(message, "org.freedesktop.login1.Seat", "Terminate")) {
+        SD_BUS_VTABLE_END
+};
 
-                r = seat_stop_sessions(s);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
+int seat_object_find(sd_bus *bus, const char *path, const char *interface, void **found, void *userdata) {
+        _cleanup_free_ char *e = NULL;
+        Manager *m = userdata;
+        Seat *seat;
+        const char *p;
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+        assert(bus);
+        assert(path);
+        assert(interface);
+        assert(found);
+        assert(m);
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Seat", "ActivateSession")) {
-                const char *name;
-                Session *session;
+        p = startswith(path, "/org/freedesktop/login1/seat/");
+        if (!p)
+                return 0;
 
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_STRING, &name,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
+        e = bus_path_unescape(p);
+        if (!e)
+                return -ENOMEM;
 
-                session = hashmap_get(s->manager->sessions, name);
-                if (!session || session->seat != s)
-                        return bus_send_error_reply(connection, message, &error, -ENOENT);
+        seat = hashmap_get(m->seats, e);
+        if (!seat)
+                return 0;
 
-                r = session_activate(session);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
-        } else {
-                const BusBoundProperties bps[] = {
-                        { "org.freedesktop.login1.Seat", bus_login_seat_properties, s },
-                        { NULL, }
-                };
-                return bus_default_message_handler(connection, message, INTROSPECTION, INTERFACES_LIST, bps);
-        }
+        *found = seat;
+        return 1;
+}
 
-        if (reply) {
-                if (!bus_maybe_send_reply(connection, message, reply))
-                        goto oom;
-        }
+char *seat_bus_path(Seat *s) {
+        _cleanup_free_ char *t = NULL;
 
-        return DBUS_HANDLER_RESULT_HANDLED;
+        assert(s);
 
-oom:
-        dbus_error_free(&error);
+        t = bus_path_escape(s->id);
+        if (!t)
+                return NULL;
 
-        return DBUS_HANDLER_RESULT_NEED_MEMORY;
+        return strappend("/org/freedesktop/login1/seat/", t);
 }
 
-static DBusHandlerResult seat_message_handler(
-                DBusConnection *connection,
-                DBusMessage *message,
-                void *userdata) {
-
+int seat_node_enumerator(sd_bus *bus, const char *path, char ***nodes, void *userdata) {
+        _cleanup_strv_free_ char **l = NULL;
         Manager *m = userdata;
-        Seat *s;
+        Seat *seat;
+        Iterator i;
         int r;
 
-        r = get_seat_for_path(m, dbus_message_get_path(message), &s);
-        if (r < 0) {
+        assert(bus);
+        assert(path);
+        assert(nodes);
 
-                if (r == -ENOMEM)
-                        return DBUS_HANDLER_RESULT_NEED_MEMORY;
+        HASHMAP_FOREACH(seat, m->seats, i) {
+                char *p;
 
-                if (r == -ENOENT) {
-                        DBusError e;
+                p = seat_bus_path(seat);
+                if (!p)
+                        return -ENOMEM;
 
-                        dbus_error_init(&e);
-                        dbus_set_error_const(&e, DBUS_ERROR_UNKNOWN_OBJECT, "Unknown seat");
-                        return bus_send_error_reply(connection, message, &e, r);
+                r = strv_push(&l, p);
+                if (r < 0) {
+                        free(p);
+                        return r;
                 }
-
-                return bus_send_error_reply(connection, message, NULL, r);
         }
 
-        return seat_message_dispatch(s, connection, message);
-}
-
-const DBusObjectPathVTable bus_seat_vtable = {
-        .message_function = seat_message_handler
-};
-
-char *seat_bus_path(Seat *s) {
-        _cleanup_free_ char *t = NULL;
-
-        assert(s);
-
-        t = bus_path_escape(s->id);
-        if (!t)
-                return NULL;
+        *nodes = l;
+        l = NULL;
 
-        return strappend("/org/freedesktop/login1/seat/", t);
+        return 1;
 }
 
 int seat_send_signal(Seat *s, bool new_seat) {
-        _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
         _cleanup_free_ char *p = NULL;
 
         assert(s);
 
-        m = dbus_message_new_signal("/org/freedesktop/login1",
-                                    "org.freedesktop.login1.Manager",
-                                    new_seat ? "SeatNew" : "SeatRemoved");
-        if (!m)
-                return -ENOMEM;
-
         p = seat_bus_path(s);
         if (!p)
                 return -ENOMEM;
 
-        if (!dbus_message_append_args(
-                            m,
-                            DBUS_TYPE_STRING, &s->id,
-                            DBUS_TYPE_OBJECT_PATH, &p,
-                            DBUS_TYPE_INVALID))
-                return -ENOMEM;
-
-        if (!dbus_connection_send(s->manager->bus, m, NULL))
-                return -ENOMEM;
-
-        return 0;
+        return sd_bus_emit_signal(
+                        s->manager->bus,
+                        "/org/freedesktop/login1",
+                        "org.freedesktop.login1.Manager",
+                        new_seat ? "SeatNew" : "SeatRemoved",
+                        "so", s->id, p);
 }
 
-int seat_send_changed(Seat *s, const char *properties) {
-        _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
+int seat_send_changed(Seat *s, const char *properties, ...) {
         _cleanup_free_ char *p = NULL;
+        char **l;
 
         assert(s);
 
@@ -399,12 +354,7 @@ int seat_send_changed(Seat *s, const char *properties) {
         if (!p)
                 return -ENOMEM;
 
-        m = bus_properties_changed_new(p, "org.freedesktop.login1.Seat", properties);
-        if (!m)
-                return -ENOMEM;
-
-        if (!dbus_connection_send(s->manager->bus, m, NULL))
-                return -ENOMEM;
+        l = strv_from_stdarg_alloca(properties);
 
-        return 0;
+        return sd_bus_emit_properties_changed_strv(s->manager->bus, p, "org.freedesktop.login1.Seat", l);
 }
diff --git a/src/login/logind-seat.c b/src/login/logind-seat.c
index 6f3299bba..b30c4ce9e 100644
--- a/src/login/logind-seat.c
+++ b/src/login/logind-seat.c
@@ -27,8 +27,8 @@
 #include <linux/vt.h>
 #include <string.h>
 
-#include "systemd/sd-id128.h"
-#include "systemd/sd-messages.h"
+#include "sd-id128.h"
+#include "sd-messages.h"
 #include "logind-seat.h"
 #include "logind-acl.h"
 #include "util.h"
@@ -84,9 +84,9 @@ void seat_free(Seat *s) {
 }
 
 int seat_save(Seat *s) {
+        _cleanup_free_ char *temp_path = NULL;
+        _cleanup_fclose_ FILE *f = NULL;
         int r;
-        FILE *f;
-        char *temp_path;
 
         assert(s);
 
@@ -151,9 +151,6 @@ int seat_save(Seat *s) {
                 unlink(temp_path);
         }
 
-        fclose(f);
-        free(temp_path);
-
 finish:
         if (r < 0)
                 log_error("Failed to save seat data for %s: %s", s->id, strerror(-r));
@@ -170,8 +167,8 @@ int seat_load(Seat *s) {
 }
 
 static int vt_allocate(int vtnr) {
-        int fd, r;
-        char *p;
+        _cleanup_free_ char *p = NULL;
+        _cleanup_close_ int fd = -1;
 
         assert(vtnr >= 1);
 
@@ -179,14 +176,10 @@ static int vt_allocate(int vtnr) {
                 return -ENOMEM;
 
         fd = open_terminal(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
-        free(p);
-
-        r = fd < 0 ? -errno : 0;
+        if (fd < 0)
+                return -errno;
 
-        if (fd >= 0)
-                close_nointr_nofail(fd);
-
-        return r;
+        return 0;
 }
 
 int seat_preallocate_vts(Seat *s) {
@@ -248,18 +241,18 @@ int seat_set_active(Seat *s, Session *session) {
 
         if (old_active) {
                 session_device_pause_all(old_active);
-                session_send_changed(old_active, "Active\0");
+                session_send_changed(old_active, "Active", NULL);
         }
 
         seat_apply_acls(s, old_active);
 
         if (session && session->started) {
-                session_send_changed(session, "Active\0");
+                session_send_changed(session, "Active", NULL);
                 session_device_resume_all(session);
         }
 
         if (!session || session->started)
-                seat_send_changed(s, "ActiveSession\0");
+                seat_send_changed(s, "ActiveSession", NULL);
 
         seat_save(s);
 
@@ -417,7 +410,7 @@ int seat_attach_session(Seat *s, Session *session) {
         session->seat = s;
         LIST_PREPEND(sessions_by_seat, s->sessions, session);
 
-        seat_send_changed(s, "Sessions\0");
+        seat_send_changed(s, "Sessions", NULL);
 
         /* On seats with VTs, the VT logic defines which session is active. On
          * seats without VTs, we automatically activate the first session. */
@@ -515,14 +508,14 @@ int seat_get_idle_hint(Seat *s, dual_timestamp *t) {
         return idle_hint;
 }
 
-int seat_check_gc(Seat *s, bool drop_not_started) {
+bool seat_check_gc(Seat *s, bool drop_not_started) {
         assert(s);
 
         if (drop_not_started && !s->started)
-                return 0;
+                return false;
 
         if (seat_is_seat0(s))
-                return 1;
+                return true;
 
         return seat_has_master_device(s);
 }
diff --git a/src/login/logind-seat.h b/src/login/logind-seat.h
index be6db6eed..0547dec07 100644
--- a/src/login/logind-seat.h
+++ b/src/login/logind-seat.h
@@ -75,13 +75,16 @@ int seat_start(Seat *s);
 int seat_stop(Seat *s);
 int seat_stop_sessions(Seat *s);
 
-int seat_check_gc(Seat *s, bool drop_not_started);
+bool seat_check_gc(Seat *s, bool drop_not_started);
 void seat_add_to_gc_queue(Seat *s);
 
 bool seat_name_is_valid(const char *name);
-char *seat_bus_path(Seat *s);
 
-extern const DBusObjectPathVTable bus_seat_vtable;
+extern const sd_bus_vtable seat_vtable[];
+
+int seat_node_enumerator(sd_bus *bus, const char *path, char ***nodes, void *userdata);
+int seat_object_find(sd_bus *bus, const char *path, const char *interface, void **found, void *seatdata);
+char *seat_bus_path(Seat *s);
 
 int seat_send_signal(Seat *s, bool new_seat);
-int seat_send_changed(Seat *s, const char *properties);
+int seat_send_changed(Seat *s, const char *properties, ...) _sentinel_;
diff --git a/src/login/logind-session-dbus.c b/src/login/logind-session-dbus.c
index be4e01c5e..cda6a0a48 100644
--- a/src/login/logind-session-dbus.c
+++ b/src/login/logind-session-dbus.c
@@ -22,191 +22,151 @@
 #include <errno.h>
 #include <string.h>
 
+#include "util.h"
+#include "strv.h"
+#include "bus-util.h"
+
 #include "logind.h"
 #include "logind-session.h"
 #include "logind-session-device.h"
-#include "dbus-common.h"
-#include "util.h"
 
-#define BUS_SESSION_INTERFACE \
-        " <interface name=\"org.freedesktop.login1.Session\">\n"        \
-        "  <method name=\"Terminate\"/>\n"                              \
-        "  <method name=\"Activate\"/>\n"                               \
-        "  <method name=\"Lock\"/>\n"                                   \
-        "  <method name=\"Unlock\"/>\n"                                 \
-        "  <method name=\"SetIdleHint\">\n"                             \
-        "   <arg name=\"b\" type=\"b\"/>\n"                             \
-        "  </method>\n"                                                 \
-        "  <method name=\"Kill\">\n"                                    \
-        "   <arg name=\"who\" type=\"s\"/>\n"                           \
-        "   <arg name=\"signal\" type=\"s\"/>\n"                        \
-        "  </method>\n"                                                 \
-        "  <method name=\"TakeControl\">\n"                             \
-        "   <arg name=\"force\" type=\"b\"/>\n"                         \
-        "  </method>\n"                                                 \
-        "  <method name=\"ReleaseControl\"/>\n"                         \
-        "  <method name=\"TakeDevice\">\n"                              \
-        "   <arg name=\"major\" type=\"u\" direction=\"in\"/>\n"        \
-        "   <arg name=\"minor\" type=\"u\" direction=\"in\"/>\n"        \
-        "   <arg name=\"fd\" type=\"h\" direction=\"out\"/>\n"          \
-        "   <arg name=\"paused\" type=\"b\" direction=\"out\"/>\n"      \
-        "  </method>\n"                                                 \
-        "  <method name=\"ReleaseDevice\">\n"                           \
-        "   <arg name=\"major\" type=\"u\"/>\n"                         \
-        "   <arg name=\"minor\" type=\"u\"/>\n"                         \
-        "  </method>\n"                                                 \
-        "  <method name=\"PauseDeviceComplete\">\n"                     \
-        "   <arg name=\"major\" type=\"u\"/>\n"                         \
-        "   <arg name=\"minor\" type=\"u\"/>\n"                         \
-        "  </method>\n"                                                 \
-        "  <signal name=\"PauseDevice\">\n"                             \
-        "   <arg name=\"major\" type=\"u\"/>\n"                         \
-        "   <arg name=\"minor\" type=\"u\"/>\n"                         \
-        "   <arg name=\"type\" type=\"s\"/>\n"                          \
-        "  </signal>\n"                                                 \
-        "  <signal name=\"ResumeDevice\">\n"                            \
-        "   <arg name=\"major\" type=\"u\"/>\n"                         \
-        "   <arg name=\"minor\" type=\"u\"/>\n"                         \
-        "   <arg name=\"fd\" type=\"h\"/>\n"                            \
-        "  </signal>\n"                                                 \
-        "  <signal name=\"Lock\"/>\n"                                   \
-        "  <signal name=\"Unlock\"/>\n"                                 \
-        "  <property name=\"Id\" type=\"s\" access=\"read\"/>\n"        \
-        "  <property name=\"User\" type=\"(uo)\" access=\"read\"/>\n"   \
-        "  <property name=\"Name\" type=\"s\" access=\"read\"/>\n"      \
-        "  <property name=\"Timestamp\" type=\"t\" access=\"read\"/>\n" \
-        "  <property name=\"TimestampMonotonic\" type=\"t\" access=\"read\"/>\n" \
-        "  <property name=\"VTNr\" type=\"u\" access=\"read\"/>\n"      \
-        "  <property name=\"Seat\" type=\"(so)\" access=\"read\"/>\n"   \
-        "  <property name=\"TTY\" type=\"s\" access=\"read\"/>\n"       \
-        "  <property name=\"Display\" type=\"s\" access=\"read\"/>\n"   \
-        "  <property name=\"Remote\" type=\"b\" access=\"read\"/>\n"    \
-        "  <property name=\"RemoteHost\" type=\"s\" access=\"read\"/>\n" \
-        "  <property name=\"RemoteUser\" type=\"s\" access=\"read\"/>\n" \
-        "  <property name=\"Service\" type=\"s\" access=\"read\"/>\n"   \
-        "  <property name=\"Scope\" type=\"s\" access=\"read\"/>\n"     \
-        "  <property name=\"Leader\" type=\"u\" access=\"read\"/>\n"    \
-        "  <property name=\"Audit\" type=\"u\" access=\"read\"/>\n"     \
-        "  <property name=\"Type\" type=\"s\" access=\"read\"/>\n"      \
-        "  <property name=\"Class\" type=\"s\" access=\"read\"/>\n"     \
-        "  <property name=\"Active\" type=\"b\" access=\"read\"/>\n"    \
-        "  <property name=\"State\" type=\"s\" access=\"read\"/>\n"     \
-        "  <property name=\"IdleHint\" type=\"b\" access=\"read\"/>\n"  \
-        "  <property name=\"IdleSinceHint\" type=\"t\" access=\"read\"/>\n" \
-        "  <property name=\"IdleSinceHintMonotonic\" type=\"t\" access=\"read\"/>\n" \
-        " </interface>\n"
-
-#define INTROSPECTION                                                   \
-        DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE                       \
-        "<node>\n"                                                      \
-        BUS_SESSION_INTERFACE                                           \
-        BUS_PROPERTIES_INTERFACE                                        \
-        BUS_PEER_INTERFACE                                              \
-        BUS_INTROSPECTABLE_INTERFACE                                    \
-        "</node>\n"
-
-#define INTERFACES_LIST                              \
-        BUS_GENERIC_INTERFACES_LIST                  \
-        "org.freedesktop.login1.Session\0"
-
-static int bus_session_append_seat(DBusMessageIter *i, const char *property, void *data) {
-        DBusMessageIter sub;
-        Session *s = data;
-        const char *id, *path;
-        char *p = NULL;
-
-        assert(i);
-        assert(property);
+static int property_get_user(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                sd_bus_error *error,
+                void *userdata) {
+
+        _cleanup_free_ char *p = NULL;
+        Session *s = userdata;
+
+        assert(bus);
+        assert(reply);
         assert(s);
 
-        if (!dbus_message_iter_open_container(i, DBUS_TYPE_STRUCT, NULL, &sub))
+        p = user_bus_path(s->user);
+        if (!p)
                 return -ENOMEM;
 
-        if (s->seat) {
-                id = s->seat->id;
-                path = p = seat_bus_path(s->seat);
+        return sd_bus_message_append(reply, "(uo)", (uint32_t) s->user->uid, p);
+}
 
-                if (!p)
-                        return -ENOMEM;
-        } else {
-                id = "";
-                path = "/";
-        }
+static int property_get_name(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                sd_bus_error *error,
+                void *userdata) {
 
-        if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &id) ||
-            !dbus_message_iter_append_basic(&sub, DBUS_TYPE_OBJECT_PATH, &path))
-                return -ENOMEM;
+        Session *s = userdata;
 
-        if (!dbus_message_iter_close_container(i, &sub))
-                return -ENOMEM;
+        assert(bus);
+        assert(reply);
+        assert(s);
 
-        return 0;
+        return sd_bus_message_append(reply, "s", s->user->name);
 }
 
-static int bus_session_append_user(DBusMessageIter *i, const char *property, void *data) {
-        DBusMessageIter sub;
-        User *u = data;
-        _cleanup_free_ char *p = NULL;
+static int property_get_seat(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                sd_bus_error *error,
+                void *userdata) {
 
-        assert(i);
-        assert(property);
-        assert(u);
+        _cleanup_free_ char *p = NULL;
+        Session *s = userdata;
 
-        if (!dbus_message_iter_open_container(i, DBUS_TYPE_STRUCT, NULL, &sub))
-                return -ENOMEM;
+        assert(bus);
+        assert(reply);
+        assert(s);
 
-        p = user_bus_path(u);
+        p = s->seat ? seat_bus_path(s->seat) : strdup("/");
         if (!p)
                 return -ENOMEM;
 
-        if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &u->uid) ||
-            !dbus_message_iter_append_basic(&sub, DBUS_TYPE_OBJECT_PATH, &p))
-                return -ENOMEM;
+        return sd_bus_message_append(reply, "(so)", s->seat ? s->seat->id : "", p);
+}
 
-        if (!dbus_message_iter_close_container(i, &sub))
-                return -ENOMEM;
+static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_type, session_type, SessionType);
+static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_class, session_class, SessionClass);
 
-        return 0;
-}
+static int property_get_active(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                sd_bus_error *error,
+                void *userdata) {
 
-static int bus_session_append_active(DBusMessageIter *i, const char *property, void *data) {
-        Session *s = data;
-        dbus_bool_t b;
+        Session *s = userdata;
 
-        assert(i);
-        assert(property);
+        assert(bus);
+        assert(reply);
         assert(s);
 
-        b = session_is_active(s);
-        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
-                return -ENOMEM;
-
-        return 0;
+        return sd_bus_message_append(reply, "b", session_is_active(s));
 }
 
-static int bus_session_append_idle_hint(DBusMessageIter *i, const char *property, void *data) {
-        Session *s = data;
-        int b;
+static int property_get_state(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                sd_bus_error *error,
+                void *userdata) {
 
-        assert(i);
-        assert(property);
+        Session *s = userdata;
+
+        assert(bus);
+        assert(reply);
         assert(s);
 
-        b = session_get_idle_hint(s, NULL) > 0;
-        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
-                return -ENOMEM;
+        return sd_bus_message_append(reply, "s", session_state_to_string(session_get_state(s)));
+}
+
+static int property_get_idle_hint(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                sd_bus_error *error,
+                void *userdata) {
 
-        return 0;
+        Session *s = userdata;
+
+        assert(bus);
+        assert(reply);
+        assert(s);
+
+        return sd_bus_message_append(reply, "b", session_get_idle_hint(s, NULL) > 0);
 }
 
-static int bus_session_append_idle_hint_since(DBusMessageIter *i, const char *property, void *data) {
-        Session *s = data;
+static int property_get_idle_since_hint(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                sd_bus_error *error,
+                void *userdata) {
+
+        Session *s = userdata;
         dual_timestamp t;
         uint64_t u;
         int r;
 
-        assert(i);
-        assert(property);
+        assert(bus);
+        assert(reply);
         assert(s);
 
         r = session_get_idle_hint(s, &t);
@@ -215,382 +175,323 @@ static int bus_session_append_idle_hint_since(DBusMessageIter *i, const char *pr
 
         u = streq(property, "IdleSinceHint") ? t.realtime : t.monotonic;
 
-        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, &u))
-                return -ENOMEM;
-
-        return 0;
+        return sd_bus_message_append(reply, "t", u);
 }
 
-static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_session_append_type, session_type, SessionType);
-static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_session_append_class, session_class, SessionClass);
-
-static int bus_session_append_state(DBusMessageIter *i, const char *property, void *data) {
-        Session *s = data;
-        const char *state;
+static int method_terminate(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Session *s = userdata;
+        int r;
 
-        assert(i);
-        assert(property);
+        assert(bus);
+        assert(message);
         assert(s);
 
-        state = session_state_to_string(session_get_state(s));
-
-        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &state))
-                return -ENOMEM;
+        r = session_stop(s);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-        return 0;
+        return sd_bus_reply_method_return(bus, message, NULL);
 }
 
-static int get_session_for_path(Manager *m, const char *path, Session **_s) {
-        _cleanup_free_ char *id = NULL;
-        Session *s;
+static int method_activate(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Session *s = userdata;
+        int r;
 
-        assert(m);
-        assert(path);
-        assert(_s);
+        assert(bus);
+        assert(message);
+        assert(s);
 
-        if (!startswith(path, "/org/freedesktop/login1/session/"))
-                return -EINVAL;
+        r = session_activate(s);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-        id = bus_path_unescape(path + 32);
-        if (!id)
-                return -ENOMEM;
+        return sd_bus_reply_method_return(bus, message, NULL);
+}
+
+static int method_lock(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Session *s = userdata;
+        int r;
+
+        assert(bus);
+        assert(message);
+        assert(s);
 
-        s = hashmap_get(m->sessions, id);
-        if (!s)
-                return -ENOENT;
+        r = session_send_lock(s, streq(sd_bus_message_get_member(message), "Lock"));
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-        *_s = s;
-        return 0;
+        return sd_bus_reply_method_return(bus, message, NULL);
 }
 
-static const BusProperty bus_login_session_properties[] = {
-        { "Id",                     bus_property_append_string,         "s", offsetof(Session, id),                 true },
-        { "Timestamp",              bus_property_append_usec,           "t", offsetof(Session, timestamp.realtime)  },
-        { "TimestampMonotonic",     bus_property_append_usec,           "t", offsetof(Session, timestamp.monotonic) },
-        { "VTNr",                   bus_property_append_uint32,         "u", offsetof(Session, vtnr)                },
-        { "Seat",                   bus_session_append_seat,         "(so)", 0 },
-        { "TTY",                    bus_property_append_string,         "s", offsetof(Session, tty),                true },
-        { "Display",                bus_property_append_string,         "s", offsetof(Session, display),            true },
-        { "Remote",                 bus_property_append_bool,           "b", offsetof(Session, remote)              },
-        { "RemoteUser",             bus_property_append_string,         "s", offsetof(Session, remote_user),        true },
-        { "RemoteHost",             bus_property_append_string,         "s", offsetof(Session, remote_host),        true },
-        { "Service",                bus_property_append_string,         "s", offsetof(Session, service),            true },
-        { "Scope",                  bus_property_append_string,         "s", offsetof(Session, scope),              true },
-        { "Leader",                 bus_property_append_pid,            "u", offsetof(Session, leader)              },
-        { "Audit",                  bus_property_append_uint32,         "u", offsetof(Session, audit_id)            },
-        { "Type",                   bus_session_append_type,            "s", offsetof(Session, type)                },
-        { "Class",                  bus_session_append_class,           "s", offsetof(Session, class)               },
-        { "Active",                 bus_session_append_active,          "b", 0 },
-        { "State",                  bus_session_append_state,           "s", 0 },
-        { "IdleHint",               bus_session_append_idle_hint,       "b", 0 },
-        { "IdleSinceHint",          bus_session_append_idle_hint_since, "t", 0 },
-        { "IdleSinceHintMonotonic", bus_session_append_idle_hint_since, "t", 0 },
-        { NULL, }
-};
+static int method_set_idle_hint(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Session *s = userdata;
+        uid_t uid;
+        int r, b;
 
-static const BusProperty bus_login_session_user_properties[] = {
-        { "User",                   bus_session_append_user,         "(uo)", 0 },
-        { "Name",                   bus_property_append_string,         "s", offsetof(User, name),                  true },
-        { NULL, }
-};
+        assert(bus);
+        assert(message);
+        assert(s);
+
+        r = sd_bus_message_read(message, "b", &b);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-static DBusHandlerResult session_message_dispatch(
-                Session *s,
-                DBusConnection *connection,
-                DBusMessage *message) {
+        r = sd_bus_get_owner_uid(bus, sd_bus_message_get_sender(message), &uid);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        if (uid != 0 && uid != s->user->uid)
+                return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_ACCESS_DENIED, "Only owner of session my set idle hint");
+
+        session_set_idle_hint(s, b);
 
-        DBusError error;
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+        return sd_bus_reply_method_return(bus, message, NULL);
+}
+
+static int method_kill(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Session *s = userdata;
+        const char *swho;
+        int32_t signo;
+        KillWho who;
         int r;
 
-        assert(s);
-        assert(connection);
+        assert(bus);
         assert(message);
+        assert(s);
 
-        dbus_error_init(&error);
+        r = sd_bus_message_read(message, "si", &swho, &signo);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        if (isempty(swho))
+                who = KILL_ALL;
+        else {
+                who = kill_who_from_string(swho);
+                if (who < 0)
+                        return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid kill parameter '%s'", swho);
+        }
 
-        if (dbus_message_is_method_call(message, "org.freedesktop.login1.Session", "Terminate")) {
+        if (signo <= 0 || signo >= _NSIG)
+                return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal %i", signo);
 
-                r = session_stop(s);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
+        r = session_kill(s, who, signo);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+        return sd_bus_reply_method_return(bus, message, NULL);
+}
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Session", "Activate")) {
+static int method_take_control(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Session *s = userdata;
+        int r, force;
+        uid_t uid;
 
-                r = session_activate(s);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
+        assert(bus);
+        assert(message);
+        assert(s);
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+        r = sd_bus_message_read(message, "b", &force);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Session", "Lock") ||
-                   dbus_message_is_method_call(message, "org.freedesktop.login1.Session", "Unlock")) {
+        r = sd_bus_get_owner_uid(bus, sd_bus_message_get_sender(message), &uid);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-                if (session_send_lock(s, streq(dbus_message_get_member(message), "Lock")) < 0)
-                        goto oom;
+        if (uid != 0 && (force || uid != s->user->uid))
+                return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_ACCESS_DENIED, "Only owner of session may take control");
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+        r = session_set_controller(s, sd_bus_message_get_sender(message), force);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Session", "SetIdleHint")) {
-                dbus_bool_t b;
-                unsigned long ul;
+        return sd_bus_reply_method_return(bus, message, NULL);
+}
 
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_BOOLEAN, &b,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
+static int method_release_control(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Session *s = userdata;
 
-                ul = dbus_bus_get_unix_user(connection, dbus_message_get_sender(message), &error);
-                if (ul == (unsigned long) -1)
-                        return bus_send_error_reply(connection, message, &error, -EIO);
+        assert(bus);
+        assert(message);
+        assert(s);
 
-                if (ul != 0 && ul != s->user->uid)
-                        return bus_send_error_reply(connection, message, NULL, -EPERM);
+        if (!session_is_controller(s, sd_bus_message_get_sender(message)))
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NOT_IN_CONTROL, "You are not in control of this session");
 
-                session_set_idle_hint(s, b);
+        session_drop_controller(s);
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+        return sd_bus_reply_method_return(bus, message, NULL);
+}
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Session", "Kill")) {
-                const char *swho;
-                int32_t signo;
-                KillWho who;
+static int method_take_device(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Session *s = userdata;
+        uint32_t major, minor;
+        SessionDevice *sd;
+        dev_t dev;
+        int r;
 
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_STRING, &swho,
-                                    DBUS_TYPE_INT32, &signo,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
+        assert(bus);
+        assert(message);
+        assert(s);
 
-                if (isempty(swho))
-                        who = KILL_ALL;
-                else {
-                        who = kill_who_from_string(swho);
-                        if (who < 0)
-                                return bus_send_error_reply(connection, message, &error, -EINVAL);
-                }
+        r = sd_bus_message_read(message, "uu", &major, &minor);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        if (!session_is_controller(s, sd_bus_message_get_sender(message)))
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NOT_IN_CONTROL, "You are not in control of this session");
+
+        dev = makedev(major, minor);
+        sd = hashmap_get(s->devices, &dev);
+        if (sd)
+                /* We don't allow retrieving a device multiple times.
+                 * The related ReleaseDevice call is not ref-counted.
+                 * The caller should use dup() if it requires more
+                 * than one fd (it would be functionally
+                 * equivalent). */
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_DEVICE_IS_TAKEN, "Device already taken");
+
+        r = session_device_new(s, dev, &sd);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-                if (signo <= 0 || signo >= _NSIG)
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
-
-                r = session_kill(s, who, signo);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Session", "TakeControl")) {
-                dbus_bool_t force;
-                unsigned long ul;
-
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_BOOLEAN, &force,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
-
-                ul = dbus_bus_get_unix_user(connection, dbus_message_get_sender(message), &error);
-                if (ul == (unsigned long) -1)
-                        return bus_send_error_reply(connection, message, &error, -EIO);
-
-                if (ul != 0 && (force || ul != s->user->uid))
-                        return bus_send_error_reply(connection, message, NULL, -EPERM);
-
-                r = session_set_controller(s, bus_message_get_sender_with_fallback(message), force);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Session", "ReleaseControl")) {
-                const char *sender = bus_message_get_sender_with_fallback(message);
-
-                if (!session_is_controller(s, sender))
-                        return bus_send_error_reply(connection, message, NULL, -EPERM);
-
-                session_drop_controller(s);
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Session", "TakeDevice")) {
-                SessionDevice *sd;
-                bool b;
-                dbus_bool_t paused;
-                uint32_t major, minor;
-                dev_t dev;
-
-                if (!session_is_controller(s, bus_message_get_sender_with_fallback(message)))
-                        return bus_send_error_reply(connection, message, NULL, -EPERM);
-
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_UINT32, &major,
-                                    DBUS_TYPE_UINT32, &minor,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
-
-                dev = makedev(major, minor);
-                sd = hashmap_get(s->devices, &dev);
-                if (sd) {
-                        /* We don't allow retrieving a device multiple times.
-                         * The related ReleaseDevice call is not ref-counted.
-                         * The caller should use dup() if it requires more than
-                         * one fd (it would be functionally equivalent). */
-                        return bus_send_error_reply(connection, message, &error, -EBUSY);
-                }
+        r = sd_bus_reply_method_return(bus, message, "hb", sd->fd, !sd->active);
+        if (r < 0)
+                session_device_free(sd);
 
-                r = session_device_new(s, dev, &sd);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
+        return r;
+}
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply) {
-                        session_device_free(sd);
-                        goto oom;
-                }
+static int method_release_device(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Session *s = userdata;
+        uint32_t major, minor;
+        SessionDevice *sd;
+        dev_t dev;
+        int r;
 
-                paused = !sd->active;
-                b = dbus_message_append_args(
-                                reply,
-                                DBUS_TYPE_UNIX_FD, &sd->fd,
-                                DBUS_TYPE_BOOLEAN, &paused,
-                                DBUS_TYPE_INVALID);
-                if (!b) {
-                        session_device_free(sd);
-                        return bus_send_error_reply(connection, message, NULL, -ENOMEM);
-                }
+        assert(bus);
+        assert(message);
+        assert(s);
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Session", "ReleaseDevice")) {
-                SessionDevice *sd;
-                uint32_t major, minor;
-                dev_t dev;
+        r = sd_bus_message_read(message, "uu", &major, &minor);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-                if (!session_is_controller(s, bus_message_get_sender_with_fallback(message)))
-                        return bus_send_error_reply(connection, message, NULL, -EPERM);
+        if (!session_is_controller(s, sd_bus_message_get_sender(message)))
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NOT_IN_CONTROL, "You are not in control of this session");
 
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_UINT32, &major,
-                                    DBUS_TYPE_UINT32, &minor,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
+        dev = makedev(major, minor);
+        sd = hashmap_get(s->devices, &dev);
+        if (!sd)
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_DEVICE_NOT_TAKEN, "Device not taken");
 
-                dev = makedev(major, minor);
-                sd = hashmap_get(s->devices, &dev);
-                if (!sd)
-                        return bus_send_error_reply(connection, message, NULL, -ENODEV);
+        session_device_free(sd);
+        return sd_bus_reply_method_return(bus, message, NULL);
+}
 
-                session_device_free(sd);
+static int method_pause_device_complete(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        Session *s = userdata;
+        uint32_t major, minor;
+        SessionDevice *sd;
+        dev_t dev;
+        int r;
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Session", "PauseDeviceComplete")) {
-                SessionDevice *sd;
-                uint32_t major, minor;
-                dev_t dev;
-
-                if (!session_is_controller(s, bus_message_get_sender_with_fallback(message)))
-                        return bus_send_error_reply(connection, message, NULL, -EPERM);
-
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_UINT32, &major,
-                                    DBUS_TYPE_UINT32, &minor,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
-
-                dev = makedev(major, minor);
-                sd = hashmap_get(s->devices, &dev);
-                if (!sd)
-                        return bus_send_error_reply(connection, message, NULL, -ENODEV);
-
-                session_device_complete_pause(sd);
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
-
-        } else {
-                const BusBoundProperties bps[] = {
-                        { "org.freedesktop.login1.Session", bus_login_session_properties,      s       },
-                        { "org.freedesktop.login1.Session", bus_login_session_user_properties, s->user },
-                        { NULL, }
-                };
-                return bus_default_message_handler(connection, message, INTROSPECTION, INTERFACES_LIST, bps);
-        }
+        assert(bus);
+        assert(message);
+        assert(s);
 
-        if (reply) {
-                if (!bus_maybe_send_reply(connection, message, reply))
-                        goto oom;
-        }
+        r = sd_bus_message_read(message, "uu", &major, &minor);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+        if (!session_is_controller(s, sd_bus_message_get_sender(message)))
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NOT_IN_CONTROL, "You are not in control of this session");
 
-        return DBUS_HANDLER_RESULT_HANDLED;
+        dev = makedev(major, minor);
+        sd = hashmap_get(s->devices, &dev);
+        if (!sd)
+                return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_DEVICE_NOT_TAKEN, "Device not taken");
 
-oom:
-        dbus_error_free(&error);
+        session_device_complete_pause(sd);
 
-        return DBUS_HANDLER_RESULT_NEED_MEMORY;
+        return sd_bus_reply_method_return(bus, message, NULL);
 }
 
-static DBusHandlerResult session_message_handler(
-                DBusConnection *connection,
-                DBusMessage *message,
-                void *userdata) {
+const sd_bus_vtable session_vtable[] = {
+        SD_BUS_VTABLE_START(0),
+
+        SD_BUS_PROPERTY("Id", "s", NULL, offsetof(Session, id), 0),
+        SD_BUS_PROPERTY("User", "(uo)", property_get_user, 0, 0),
+        SD_BUS_PROPERTY("Name", "s", property_get_name, 0, 0),
+        SD_BUS_PROPERTY("Timestamp", "t", NULL, offsetof(Session, timestamp.realtime), 0),
+        SD_BUS_PROPERTY("TimestampMonotonic", "t", NULL, offsetof(Session, timestamp.monotonic), 0),
+        SD_BUS_PROPERTY("VTNr", "u", NULL, offsetof(Session, vtnr), 0),
+        SD_BUS_PROPERTY("Seat", "(so)", property_get_seat, 0, 0),
+        SD_BUS_PROPERTY("TTY", "s", NULL, offsetof(Session, tty), 0),
+        SD_BUS_PROPERTY("Display", "s", NULL, offsetof(Session, display), 0),
+        SD_BUS_PROPERTY("Remote", "b", bus_property_get_bool, offsetof(Session, remote), 0),
+        SD_BUS_PROPERTY("RemoteHost", "s", NULL, offsetof(Session, remote_host), 0),
+        SD_BUS_PROPERTY("RemoteUser", "s", NULL, offsetof(Session, remote_user), 0),
+        SD_BUS_PROPERTY("Service", "s", NULL, offsetof(Session, service), 0),
+        SD_BUS_PROPERTY("Scope", "s", NULL, offsetof(Session, scope), 0),
+        SD_BUS_PROPERTY("Leader", "u", bus_property_get_pid, offsetof(Session, leader), 0),
+        SD_BUS_PROPERTY("Audit", "u", NULL, offsetof(Session, audit_id), 0),
+        SD_BUS_PROPERTY("Type", "s", property_get_type, offsetof(Session, type), 0),
+        SD_BUS_PROPERTY("Class", "s", property_get_class, offsetof(Session, class), 0),
+        SD_BUS_PROPERTY("Active", "b", property_get_active, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+        SD_BUS_PROPERTY("State", "s", property_get_state, 0, 0),
+        SD_BUS_PROPERTY("IdleHint", "b", property_get_idle_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+        SD_BUS_PROPERTY("IdleSinceHint", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+        SD_BUS_PROPERTY("IdleSinceHintMonotonic", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+
+        SD_BUS_METHOD("Terminate", NULL, NULL, method_terminate, 0),
+        SD_BUS_METHOD("Activate", NULL, NULL, method_activate, 0),
+        SD_BUS_METHOD("Lock", NULL, NULL, method_lock, 0),
+        SD_BUS_METHOD("Unlock", NULL, NULL, method_lock, 0),
+        SD_BUS_METHOD("SetIdleHint", "b", NULL, method_set_idle_hint, 0),
+        SD_BUS_METHOD("Kill", "si", NULL, method_kill, 0),
+        SD_BUS_METHOD("TakeControl", "b", NULL, method_take_control, 0),
+        SD_BUS_METHOD("ReleaseControl", NULL, NULL, method_release_control, 0),
+        SD_BUS_METHOD("TakeDevice", "uu", "hb", method_take_device, 0),
+        SD_BUS_METHOD("ReleaseDevice", "uu", NULL, method_release_device, 0),
+        SD_BUS_METHOD("PauseDeviceComplete", "uu", NULL, method_pause_device_complete, 0),
+
+        SD_BUS_SIGNAL("PauseDevice", "uus", 0),
+        SD_BUS_SIGNAL("ResumeDevice", "uuh", 0),
+        SD_BUS_SIGNAL("Lock", NULL, 0),
+        SD_BUS_SIGNAL("Unlock", NULL, 0),
+
+        SD_BUS_VTABLE_END
+};
 
+int session_object_find(sd_bus *bus, const char *path, const char *interface, void **found, void *userdata) {
+        _cleanup_free_ char *e = NULL;
         Manager *m = userdata;
-        Session *s;
-        int r;
-
-        r = get_session_for_path(m, dbus_message_get_path(message), &s);
-        if (r < 0) {
+        Session *session;
+        const char *p;
 
-                if (r == -ENOMEM)
-                        return DBUS_HANDLER_RESULT_NEED_MEMORY;
+        assert(bus);
+        assert(path);
+        assert(interface);
+        assert(found);
+        assert(m);
 
-                if (r == -ENOENT) {
-                        DBusError e;
+        p = startswith(path, "/org/freedesktop/login1/session/");
+        if (!p)
+                return 0;
 
-                        dbus_error_init(&e);
-                        dbus_set_error_const(&e, DBUS_ERROR_UNKNOWN_OBJECT, "Unknown session");
-                        return bus_send_error_reply(connection, message, &e, r);
-                }
+        e = bus_path_unescape(p);
+        if (!e)
+                return -ENOMEM;
 
-                return bus_send_error_reply(connection, message, NULL, r);
-        }
+        session = hashmap_get(m->sessions, e);
+        if (!session)
+                return 0;
 
-        return session_message_dispatch(s, connection, message);
+        *found = session;
+        return 1;
 }
 
-const DBusObjectPathVTable bus_session_vtable = {
-        .message_function = session_message_handler
-};
-
 char *session_bus_path(Session *s) {
         _cleanup_free_ char *t = NULL;
 
@@ -603,39 +504,57 @@ char *session_bus_path(Session *s) {
         return strappend("/org/freedesktop/login1/session/", t);
 }
 
+int session_node_enumerator(sd_bus *bus, const char *path, char ***nodes, void *userdata) {
+        _cleanup_strv_free_ char **l = NULL;
+        Manager *m = userdata;
+        Session *session;
+        Iterator i;
+        int r;
+
+        assert(bus);
+        assert(path);
+        assert(nodes);
+
+        HASHMAP_FOREACH(session, m->sessions, i) {
+                char *p;
+
+                p = session_bus_path(session);
+                if (!p)
+                        return -ENOMEM;
+
+                r = strv_push(&l, p);
+                if (r < 0) {
+                        free(p);
+                        return r;
+                }
+        }
+
+        *nodes = l;
+        l = NULL;
+
+        return 1;
+}
+
 int session_send_signal(Session *s, bool new_session) {
-        _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
         _cleanup_free_ char *p = NULL;
 
         assert(s);
 
-        m = dbus_message_new_signal("/org/freedesktop/login1",
-                                    "org.freedesktop.login1.Manager",
-                                    new_session ? "SessionNew" : "SessionRemoved");
-
-        if (!m)
-                return -ENOMEM;
-
         p = session_bus_path(s);
         if (!p)
                 return -ENOMEM;
 
-        if (!dbus_message_append_args(
-                            m,
-                            DBUS_TYPE_STRING, &s->id,
-                            DBUS_TYPE_OBJECT_PATH, &p,
-                            DBUS_TYPE_INVALID))
-                return -ENOMEM;
-
-        if (!dbus_connection_send(s->manager->bus, m, NULL))
-                return -ENOMEM;
-
-        return 0;
+        return sd_bus_emit_signal(
+                        s->manager->bus,
+                        "/org/freedesktop/login1",
+                        "org.freedesktop.login1.Manager",
+                        new_session ? "SessionNew" : "SessionRemoved",
+                        "so", s->id, p);
 }
 
-int session_send_changed(Session *s, const char *properties) {
-        _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
+int session_send_changed(Session *s, const char *properties, ...) {
         _cleanup_free_ char *p = NULL;
+        char **l;
 
         assert(s);
 
@@ -646,19 +565,12 @@ int session_send_changed(Session *s, const char *properties) {
         if (!p)
                 return -ENOMEM;
 
-        m = bus_properties_changed_new(p, "org.freedesktop.login1.Session", properties);
-        if (!m)
-                return -ENOMEM;
-
-        if (!dbus_connection_send(s->manager->bus, m, NULL))
-                return -ENOMEM;
+        l = strv_from_stdarg_alloca(properties);
 
-        return 0;
+        return sd_bus_emit_properties_changed_strv(s->manager->bus, p, "org.freedesktop.login1.Session", l);
 }
 
 int session_send_lock(Session *s, bool lock) {
-        _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
-        bool b;
         _cleanup_free_ char *p = NULL;
 
         assert(s);
@@ -667,16 +579,12 @@ int session_send_lock(Session *s, bool lock) {
         if (!p)
                 return -ENOMEM;
 
-        m = dbus_message_new_signal(p, "org.freedesktop.login1.Session", lock ? "Lock" : "Unlock");
-
-        if (!m)
-                return -ENOMEM;
-
-        b = dbus_connection_send(s->manager->bus, m, NULL);
-        if (!b)
-                return -ENOMEM;
-
-        return 0;
+        return sd_bus_emit_signal(
+                        s->manager->bus,
+                        p,
+                        "org.freedesktop.login1.Session",
+                        lock ? "Lock" : "Unlock",
+                        NULL);
 }
 
 int session_send_lock_all(Manager *m, bool lock) {
@@ -697,80 +605,46 @@ int session_send_lock_all(Manager *m, bool lock) {
         return r;
 }
 
-int session_send_create_reply(Session *s, DBusError *error) {
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+int session_send_create_reply(Session *s, sd_bus_error *error) {
+        _cleanup_bus_message_unref_ sd_bus_message *c = NULL;
+        _cleanup_close_ int fifo_fd = -1;
+        _cleanup_free_ char *p = NULL;
 
         assert(s);
 
-        if (!s->create_message)
-                return 0;
-
         /* This is called after the session scope was successfully
          * created, and finishes where bus_manager_create_session()
          * left off. */
 
-        if (error) {
-                DBusError buffer;
-
-                dbus_error_init(&buffer);
+        if (!s->create_message)
+                return 0;
 
-                if (!dbus_error_is_set(error)) {
-                        dbus_set_error_const(&buffer, DBUS_ERROR_INVALID_ARGS, "Invalid Arguments");
-                        error = &buffer;
-                }
+        c = s->create_message;
+        s->create_message = NULL;
 
-                reply = dbus_message_new_error(s->create_message, error->name, error->message);
-                dbus_error_free(&buffer);
-
-                if (!reply)
-                        return log_oom();
-        } else {
-                _cleanup_close_ int fifo_fd = -1;
-                _cleanup_free_ char *path = NULL;
-                const char *cseat;
-                uint32_t vtnr;
-                dbus_bool_t exists;
-
-                fifo_fd = session_create_fifo(s);
-                if (fifo_fd < 0) {
-                        log_error("Failed to create fifo: %s", strerror(-fifo_fd));
-                        return fifo_fd;
-                }
+        if (error)
+                return sd_bus_reply_method_error(s->manager->bus, c, error);
 
-                path = session_bus_path(s);
-                if (!path)
-                        return log_oom();
-
-                reply = dbus_message_new_method_return(s->create_message);
-                if (!reply)
-                        return log_oom();
-
-                cseat = s->seat ? s->seat->id : "";
-                vtnr = s->vtnr;
-                exists = false;
-
-                if (!dbus_message_append_args(
-                                    reply,
-                                    DBUS_TYPE_STRING, &s->id,
-                                    DBUS_TYPE_OBJECT_PATH, &path,
-                                    DBUS_TYPE_STRING, &s->user->runtime_path,
-                                    DBUS_TYPE_UNIX_FD, &fifo_fd,
-                                    DBUS_TYPE_STRING, &cseat,
-                                    DBUS_TYPE_UINT32, &vtnr,
-                                    DBUS_TYPE_BOOLEAN, &exists,
-                                    DBUS_TYPE_INVALID))
-                        return log_oom();
-        }
-
-        /* Update the state file before we notify the client about the
-         * result */
+        /* Update the session state file before we notify the client
+         * about the result. */
         session_save(s);
 
-        if (!dbus_connection_send(s->manager->bus, reply, NULL))
-                return log_oom();
+        fifo_fd = session_create_fifo(s);
+        if (fifo_fd < 0)
+                return fifo_fd;
 
-        dbus_message_unref(s->create_message);
-        s->create_message = NULL;
+        p = session_bus_path(s);
+        if (!p)
+                return -ENOMEM;
 
-        return 0;
+        return sd_bus_reply_method_return(
+                        s->manager->bus, c,
+                        "soshsub",
+                        s->id,
+                        p,
+                        s->user->runtime_path,
+                        fifo_fd,
+                        s->seat ? s->seat->id : "",
+                        (uint32_t) s->vtnr,
+                        false);
 }
diff --git a/src/login/logind-session-device.c b/src/login/logind-session-device.c
index f1578bda9..b2ef8ccc9 100644
--- a/src/login/logind-session-device.c
+++ b/src/login/logind-session-device.c
@@ -30,10 +30,10 @@
 #include <sys/types.h>
 #include <unistd.h>
 
-#include "dbus-common.h"
-#include "logind-session-device.h"
 #include "util.h"
 #include "missing.h"
+#include "bus-util.h"
+#include "logind-session-device.h"
 
 enum SessionDeviceNotifications {
         SESSION_DEVICE_RESUME,
@@ -42,11 +42,12 @@ enum SessionDeviceNotifications {
         SESSION_DEVICE_RELEASE,
 };
 
-static void session_device_notify(SessionDevice *sd, enum SessionDeviceNotifications type) {
-        _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
+static int session_device_notify(SessionDevice *sd, enum SessionDeviceNotifications type) {
+        _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
         _cleanup_free_ char *path = NULL;
         const char *t = NULL;
         uint32_t major, minor;
+        int r;
 
         assert(sd);
 
@@ -54,29 +55,29 @@ static void session_device_notify(SessionDevice *sd, enum SessionDeviceNotificat
         minor = minor(sd->dev);
 
         if (!sd->session->controller)
-                return;
+                return 0;
 
         path = session_bus_path(sd->session);
         if (!path)
-                return;
+                return -ENOMEM;
 
-        m = dbus_message_new_signal(path,
-                                    "org.freedesktop.login1.Session",
-                                    (type == SESSION_DEVICE_RESUME) ? "ResumeDevice" : "PauseDevice");
+        r = sd_bus_message_new_signal(
+                        sd->session->manager->bus, path,
+                        "org.freedesktop.login1.Session",
+                        (type == SESSION_DEVICE_RESUME) ? "ResumeDevice" : "PauseDevice",
+                        &m);
         if (!m)
-                return;
+                return r;
 
-        if (!dbus_message_set_destination(m, sd->session->controller))
-                return;
+        r = sd_bus_message_set_destination(m, sd->session->controller);
+        if (r < 0)
+                return r;
 
         switch (type) {
         case SESSION_DEVICE_RESUME:
-                if (!dbus_message_append_args(m,
-                                              DBUS_TYPE_UINT32, &major,
-                                              DBUS_TYPE_UINT32, &minor,
-                                              DBUS_TYPE_UNIX_FD, &sd->fd,
-                                              DBUS_TYPE_INVALID))
-                        return;
+                r = sd_bus_message_append(m, "uuh", major, minor, sd->fd);
+                if (r < 0)
+                        return r;
                 break;
         case SESSION_DEVICE_TRY_PAUSE:
                 t = "pause";
@@ -88,17 +89,16 @@ static void session_device_notify(SessionDevice *sd, enum SessionDeviceNotificat
                 t = "gone";
                 break;
         default:
-                return;
+                return -EINVAL;
         }
 
-        if (t && !dbus_message_append_args(m,
-                                           DBUS_TYPE_UINT32, &major,
-                                           DBUS_TYPE_UINT32, &minor,
-                                           DBUS_TYPE_STRING, &t,
-                                           DBUS_TYPE_INVALID))
-                return;
+        if (t) {
+                r = sd_bus_message_append(m, "uus", major, minor, t);
+                if (r < 0)
+                        return r;
+        }
 
-        dbus_connection_send(sd->session->manager->bus, m, NULL);
+        return sd_bus_send(sd->session->manager->bus, m, NULL);
 }
 
 static int sd_eviocrevoke(int fd) {
diff --git a/src/login/logind-session.c b/src/login/logind-session.c
index 8a021f32a..65cc6f309 100644
--- a/src/login/logind-session.c
+++ b/src/login/logind-session.c
@@ -22,18 +22,18 @@
 #include <errno.h>
 #include <string.h>
 #include <unistd.h>
-#include <sys/epoll.h>
 #include <fcntl.h>
 
-#include <systemd/sd-id128.h>
-#include <systemd/sd-messages.h>
-
+#include "sd-id128.h"
+#include "sd-messages.h"
 #include "strv.h"
 #include "util.h"
 #include "mkdir.h"
 #include "path-util.h"
 #include "fileio.h"
-#include "dbus-common.h"
+#include "audit.h"
+#include "bus-util.h"
+#include "bus-error.h"
 #include "logind-session.h"
 
 static unsigned devt_hash_func(const void *p) {
@@ -98,6 +98,8 @@ void session_free(Session *s) {
         if (s->in_gc_queue)
                 LIST_REMOVE(gc_queue, s->manager->session_gc_queue, s);
 
+        session_remove_fifo(s);
+
         session_drop_controller(s);
 
         while ((sd = hashmap_first(s->devices)))
@@ -128,8 +130,7 @@ void session_free(Session *s) {
 
         free(s->scope_job);
 
-        if (s->create_message)
-                dbus_message_unref(s->create_message);
+        sd_bus_message_unref(s->create_message);
 
         free(s->tty);
         free(s->display);
@@ -138,7 +139,6 @@ void session_free(Session *s) {
         free(s->service);
 
         hashmap_remove(s->manager->sessions, s->id);
-        session_remove_fifo(s);
 
         free(s->state_file);
         free(s);
@@ -153,8 +153,8 @@ void session_set_user(Session *s, User *u) {
 }
 
 int session_save(Session *s) {
-        _cleanup_fclose_ FILE *f = NULL;
         _cleanup_free_ char *temp_path = NULL;
+        _cleanup_fclose_ FILE *f = NULL;
         int r = 0;
 
         assert(s);
@@ -494,16 +494,14 @@ done:
 }
 
 static int session_start_scope(Session *s) {
-        DBusError error;
         int r;
 
         assert(s);
         assert(s->user);
         assert(s->user->slice);
 
-        dbus_error_init(&error);
-
         if (!s->scope) {
+                _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
                 _cleanup_free_ char *description = NULL;
                 const char *kill_mode;
                 char *scope, *job;
@@ -521,9 +519,7 @@ static int session_start_scope(Session *s) {
                 r = manager_start_scope(s->manager, scope, s->leader, s->user->slice, description, "systemd-user-sessions.service", kill_mode, &error, &job);
                 if (r < 0) {
                         log_error("Failed to start session scope %s: %s %s",
-                                  scope, bus_error(&error, r), error.name);
-                        dbus_error_free(&error);
-
+                                  scope, bus_error_message(&error, r), error.name);
                         free(scope);
                         return r;
                 } else {
@@ -589,32 +585,29 @@ int session_start(Session *s) {
                 seat_save(s->seat);
 
                 if (s->seat->active == s)
-                        seat_send_changed(s->seat, "Sessions\0ActiveSession\0");
+                        seat_send_changed(s->seat, "Sessions", "ActiveSession", NULL);
                 else
-                        seat_send_changed(s->seat, "Sessions\0");
+                        seat_send_changed(s->seat, "Sessions", NULL);
         }
 
-        user_send_changed(s->user, "Sessions\0");
+        user_send_changed(s->user, "Sessions", NULL);
 
         return 0;
 }
 
 static int session_stop_scope(Session *s) {
-        DBusError error;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         char *job;
         int r;
 
         assert(s);
 
-        dbus_error_init(&error);
-
         if (!s->scope)
                 return 0;
 
         r = manager_stop_unit(s->manager, s->scope, &error, &job);
         if (r < 0) {
-                log_error("Failed to stop session scope: %s", bus_error(&error, r));
-                dbus_error_free(&error);
+                log_error("Failed to stop session scope: %s", bus_error_message(&error, r));
                 return r;
         }
 
@@ -656,6 +649,7 @@ int session_stop(Session *s) {
         r = session_stop_scope(s);
 
         session_save(s);
+        user_save(s->user);
 
         return r;
 }
@@ -698,11 +692,11 @@ int session_finalize(Session *s) {
                 if (s->seat->active == s)
                         seat_set_active(s->seat, NULL);
 
-                seat_send_changed(s->seat, "Sessions\0");
+                seat_send_changed(s->seat, "Sessions", NULL);
                 seat_save(s->seat);
         }
 
-        user_send_changed(s->user, "Sessions\0");
+        user_send_changed(s->user, "Sessions", NULL);
         user_save(s->user);
 
         return r;
@@ -816,26 +810,27 @@ void session_set_idle_hint(Session *s, bool b) {
         s->idle_hint = b;
         dual_timestamp_get(&s->idle_hint_timestamp);
 
-        session_send_changed(s,
-                             "IdleHint\0"
-                             "IdleSinceHint\0"
-                             "IdleSinceHintMonotonic\0");
+        session_send_changed(s, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
 
         if (s->seat)
-                seat_send_changed(s->seat,
-                                  "IdleHint\0"
-                                  "IdleSinceHint\0"
-                                  "IdleSinceHintMonotonic\0");
-
-        user_send_changed(s->user,
-                          "IdleHint\0"
-                          "IdleSinceHint\0"
-                          "IdleSinceHintMonotonic\0");
-
-        manager_send_changed(s->manager,
-                             "IdleHint\0"
-                             "IdleSinceHint\0"
-                             "IdleSinceHintMonotonic\0");
+                seat_send_changed(s->seat, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
+
+        user_send_changed(s->user, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
+        manager_send_changed(s->manager, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
+}
+
+static int session_dispatch_fifo(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
+        Session *s = userdata;
+
+        assert(s);
+        assert(s->fifo_fd == fd);
+
+        /* EOF on the FIFO means the session died abnormally. */
+
+        session_remove_fifo(s);
+        session_stop(s);
+
+        return 1;
 }
 
 int session_create_fifo(Session *s) {
@@ -858,21 +853,20 @@ int session_create_fifo(Session *s) {
 
         /* Open reading side */
         if (s->fifo_fd < 0) {
-                struct epoll_event ev = {};
-
                 s->fifo_fd = open(s->fifo_path, O_RDONLY|O_CLOEXEC|O_NDELAY);
                 if (s->fifo_fd < 0)
                         return -errno;
 
-                r = hashmap_put(s->manager->session_fds, INT_TO_PTR(s->fifo_fd + 1), s);
+        }
+
+        if (!s->fifo_event_source) {
+                r = sd_event_add_io(s->manager->event, s->fifo_fd, 0, session_dispatch_fifo, s, &s->fifo_event_source);
                 if (r < 0)
                         return r;
 
-                ev.events = 0;
-                ev.data.u32 = FD_OTHER_BASE + s->fifo_fd;
-
-                if (epoll_ctl(s->manager->epoll_fd, EPOLL_CTL_ADD, s->fifo_fd, &ev) < 0)
-                        return -errno;
+                r = sd_event_source_set_priority(s->fifo_event_source, SD_PRIORITY_IDLE);
+                if (r < 0)
+                        return r;
         }
 
         /* Open writing side */
@@ -886,14 +880,12 @@ int session_create_fifo(Session *s) {
 void session_remove_fifo(Session *s) {
         assert(s);
 
+        if (s->fifo_event_source)
+                s->fifo_event_source = sd_event_source_unref(s->fifo_event_source);
+
         if (s->fifo_fd >= 0) {
-                assert_se(hashmap_remove(s->manager->session_fds, INT_TO_PTR(s->fifo_fd + 1)) == s);
-                assert_se(epoll_ctl(s->manager->epoll_fd, EPOLL_CTL_DEL, s->fifo_fd, NULL) == 0);
                 close_nointr_nofail(s->fifo_fd);
                 s->fifo_fd = -1;
-
-                session_save(s);
-                user_save(s->user);
         }
 
         if (s->fifo_path) {
@@ -903,33 +895,33 @@ void session_remove_fifo(Session *s) {
         }
 }
 
-int session_check_gc(Session *s, bool drop_not_started) {
+bool session_check_gc(Session *s, bool drop_not_started) {
         int r;
 
         assert(s);
 
         if (drop_not_started && !s->started)
-                return 0;
+                return false;
 
         if (!s->user)
-                return 0;
+                return false;
 
         if (s->fifo_fd >= 0) {
                 r = pipe_eof(s->fifo_fd);
                 if (r < 0)
-                        return r;
+                        return true;
 
                 if (r == 0)
-                        return 1;
+                        return true;
         }
 
-        if (s->scope_job)
-                return 1;
+        if (s->scope_job && manager_job_is_active(s->manager, s->scope_job))
+                return true;
 
-        if (s->scope)
-                return manager_unit_is_active(s->manager, s->scope) != 0;
+        if (s->scope && manager_unit_is_active(s->manager, s->scope))
+                return true;
 
-        return 0;
+        return false;
 }
 
 void session_add_to_gc_queue(Session *s) {
@@ -969,8 +961,7 @@ int session_kill(Session *s, KillWho who, int signo) {
         return manager_kill_unit(s->manager, s->scope, who, signo, NULL);
 }
 
-bool session_is_controller(Session *s, const char *sender)
-{
+bool session_is_controller(Session *s, const char *sender) {
         assert(s);
 
         return streq_ptr(s->controller, sender);
diff --git a/src/login/logind-session.h b/src/login/logind-session.h
index f175a8995..bcbd4e562 100644
--- a/src/login/logind-session.h
+++ b/src/login/logind-session.h
@@ -98,6 +98,8 @@ struct Session {
         int fifo_fd;
         char *fifo_path;
 
+        sd_event_source *fifo_event_source;
+
         bool idle_hint;
         dual_timestamp idle_hint_timestamp;
 
@@ -105,7 +107,7 @@ struct Session {
         bool started:1;
         bool closing:1;
 
-        DBusMessage *create_message;
+        sd_bus_message *create_message;
 
         char *controller;
         Hashmap *devices;
@@ -119,7 +121,7 @@ struct Session {
 Session *session_new(Manager *m, const char *id);
 void session_free(Session *s);
 void session_set_user(Session *s, User *u);
-int session_check_gc(Session *s, bool drop_not_started);
+bool session_check_gc(Session *s, bool drop_not_started);
 void session_add_to_gc_queue(Session *s);
 int session_activate(Session *s);
 bool session_is_active(Session *s);
@@ -134,18 +136,19 @@ int session_save(Session *s);
 int session_load(Session *s);
 int session_kill(Session *s, KillWho who, int signo);
 
-char *session_bus_path(Session *s);
-
 SessionState session_get_state(Session *u);
 
-extern const DBusObjectPathVTable bus_session_vtable;
+extern const sd_bus_vtable session_vtable[];
+int session_node_enumerator(sd_bus *bus, const char *path, char ***nodes, void *userdata);
+int session_object_find(sd_bus *bus, const char *path, const char *interface, void **found, void *userdata);
+char *session_bus_path(Session *s);
 
 int session_send_signal(Session *s, bool new_session);
-int session_send_changed(Session *s, const char *properties);
+int session_send_changed(Session *s, const char *properties, ...) _sentinel_;
 int session_send_lock(Session *s, bool lock);
 int session_send_lock_all(Manager *m, bool lock);
 
-int session_send_create_reply(Session *s, DBusError *error);
+int session_send_create_reply(Session *s, sd_bus_error *error);
 
 const char* session_state_to_string(SessionState t) _const_;
 SessionState session_state_from_string(const char *s) _pure_;
diff --git a/src/login/logind-user-dbus.c b/src/login/logind-user-dbus.c
index fa2ecba53..fc71fcf22 100644
--- a/src/login/logind-user-dbus.c
+++ b/src/login/logind-user-dbus.c
@@ -22,309 +22,228 @@
 #include <errno.h>
 #include <string.h>
 
+#include "strv.h"
+#include "bus-util.h"
+
 #include "logind.h"
 #include "logind-user.h"
-#include "dbus-common.h"
-
-#define BUS_USER_INTERFACE \
-        " <interface name=\"org.freedesktop.login1.User\">\n"           \
-        "  <method name=\"Terminate\"/>\n"                              \
-        "  <method name=\"Kill\">\n"                                    \
-        "   <arg name=\"signal\" type=\"s\"/>\n"                        \
-        "  </method>\n"                                                 \
-        "  <property name=\"UID\" type=\"u\" access=\"read\"/>\n"       \
-        "  <property name=\"GID\" type=\"u\" access=\"read\"/>\n"       \
-        "  <property name=\"Name\" type=\"s\" access=\"read\"/>\n"      \
-        "  <property name=\"Timestamp\" type=\"t\" access=\"read\"/>\n" \
-        "  <property name=\"TimestampMonotonic\" type=\"t\" access=\"read\"/>\n" \
-        "  <property name=\"RuntimePath\" type=\"s\" access=\"read\"/>\n" \
-        "  <property name=\"Service\" type=\"s\" access=\"read\"/>\n"   \
-        "  <property name=\"Slice\" type=\"s\" access=\"read\"/>\n"     \
-        "  <property name=\"Display\" type=\"(so)\" access=\"read\"/>\n" \
-        "  <property name=\"State\" type=\"s\" access=\"read\"/>\n"     \
-        "  <property name=\"Sessions\" type=\"a(so)\" access=\"read\"/>\n" \
-        "  <property name=\"IdleHint\" type=\"b\" access=\"read\"/>\n"  \
-        "  <property name=\"IdleSinceHint\" type=\"t\" access=\"read\"/>\n" \
-        "  <property name=\"IdleSinceHintMonotonic\" type=\"t\" access=\"read\"/>\n" \
-        " </interface>\n"
-
-#define INTROSPECTION                                                   \
-        DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE                       \
-        "<node>\n"                                                      \
-        BUS_USER_INTERFACE                                              \
-        BUS_PROPERTIES_INTERFACE                                        \
-        BUS_PEER_INTERFACE                                              \
-        BUS_INTROSPECTABLE_INTERFACE                                    \
-        "</node>\n"
-
-#define INTERFACES_LIST                              \
-        BUS_GENERIC_INTERFACES_LIST                  \
-        "org.freedesktop.login1.User\0"
-
-static int bus_user_append_display(DBusMessageIter *i, const char *property, void *data) {
-        DBusMessageIter sub;
-        User *u = data;
-        const char *id, *path;
-        _cleanup_free_ char *p = NULL;
-
-        assert(i);
-        assert(property);
-        assert(u);
 
-        if (!dbus_message_iter_open_container(i, DBUS_TYPE_STRUCT, NULL, &sub))
-                return -ENOMEM;
-
-        if (u->display) {
-                id = u->display->id;
-                path = p = session_bus_path(u->display);
+static int property_get_display(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                sd_bus_error *error,
+                void *userdata) {
 
-                if (!p)
-                        return -ENOMEM;
-        } else {
-                id = "";
-                path = "/";
-        }
+        _cleanup_free_ char *p = NULL;
+        User *u = userdata;
 
-        if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &id) ||
-            !dbus_message_iter_append_basic(&sub, DBUS_TYPE_OBJECT_PATH, &path))
-                return -ENOMEM;
+        assert(bus);
+        assert(reply);
+        assert(u);
 
-        if (!dbus_message_iter_close_container(i, &sub))
+        p = u->display ? session_bus_path(u->display) : strdup("/");
+        if (!p)
                 return -ENOMEM;
 
-        return 0;
+        return sd_bus_message_append(reply, "(so)", u->display ? u->display->id : "", p);
 }
 
-static int bus_user_append_state(DBusMessageIter *i, const char *property, void *data) {
-        User *u = data;
-        const char *state;
-
-        assert(i);
-        assert(property);
-        assert(u);
+static int property_get_state(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                sd_bus_error *error,
+                void *userdata) {
 
-        state = user_state_to_string(user_get_state(u));
+        User *u = userdata;
 
-        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &state))
-                return -ENOMEM;
+        assert(bus);
+        assert(reply);
+        assert(u);
 
-        return 0;
+        return sd_bus_message_append(reply, "s", user_state_to_string(user_get_state(u)));
 }
 
-static int bus_user_append_sessions(DBusMessageIter *i, const char *property, void *data) {
-        DBusMessageIter sub, sub2;
-        User *u = data;
+static int property_get_sessions(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                sd_bus_error *error,
+                void *userdata) {
+
+        User *u = userdata;
         Session *session;
+        int r;
 
-        assert(i);
-        assert(property);
+        assert(bus);
+        assert(reply);
         assert(u);
 
-        if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "(so)", &sub))
-                return -ENOMEM;
+        r = sd_bus_message_open_container(reply, 'a', "(so)");
+        if (r < 0)
+                return r;
 
         LIST_FOREACH(sessions_by_user, session, u->sessions) {
-                char *p;
-
-                if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
-                        return -ENOMEM;
+                _cleanup_free_ char *p = NULL;
 
                 p = session_bus_path(session);
                 if (!p)
                         return -ENOMEM;
 
-                if (!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &session->id) ||
-                    !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_OBJECT_PATH, &p)) {
-                        free(p);
-                        return -ENOMEM;
-                }
-
-                free(p);
+                r = sd_bus_message_append(reply, "(so)", session->id, p);
+                if (r < 0)
+                        return r;
 
-                if (!dbus_message_iter_close_container(&sub, &sub2))
-                        return -ENOMEM;
         }
 
-        if (!dbus_message_iter_close_container(i, &sub))
-                return -ENOMEM;
+        r = sd_bus_message_close_container(reply);
+        if (r < 0)
+                return r;
 
-        return 0;
+        return 1;
 }
 
-static int bus_user_append_idle_hint(DBusMessageIter *i, const char *property, void *data) {
-        User *u = data;
-        dbus_bool_t b;
-
-        assert(i);
-        assert(property);
-        assert(u);
+static int property_get_idle_hint(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                sd_bus_error *error,
+                void *userdata) {
 
-        b = user_get_idle_hint(u, NULL) > 0;
+        User *u = userdata;
 
-        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
-                return -ENOMEM;
+        assert(bus);
+        assert(reply);
+        assert(u);
 
-        return 0;
+        return sd_bus_message_append(reply, "b", user_get_idle_hint(u, NULL) > 0);
 }
 
-static int bus_user_append_idle_hint_since(DBusMessageIter *i, const char *property, void *data) {
-        User *u = data;
+static int property_get_idle_since_hint(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                sd_bus_error *error,
+                void *userdata) {
+
+        User *u = userdata;
         dual_timestamp t;
         uint64_t k;
 
-        assert(i);
-        assert(property);
+        assert(bus);
+        assert(reply);
         assert(u);
 
         user_get_idle_hint(u, &t);
         k = streq(property, "IdleSinceHint") ? t.realtime : t.monotonic;
 
-        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, &k))
-                return -ENOMEM;
-
-        return 0;
+        return sd_bus_message_append(reply, "t", k);
 }
 
-static int get_user_for_path(Manager *m, const char *path, User **_u) {
-        User *u;
-        unsigned long lu;
+static int method_terminate(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        User *u = userdata;
         int r;
 
-        assert(m);
-        assert(path);
-        assert(_u);
-
-        if (!startswith(path, "/org/freedesktop/login1/user/_"))
-                return -EINVAL;
+        assert(bus);
+        assert(message);
+        assert(u);
 
-        r = safe_atolu(path + 30, &lu);
+        r = user_stop(u);
         if (r < 0)
-                return r;
-
-        u = hashmap_get(m->users, ULONG_TO_PTR(lu));
-        if (!u)
-                return -ENOENT;
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-        *_u = u;
-        return 0;
+        return sd_bus_reply_method_return(bus, message, NULL);
 }
 
-static const BusProperty bus_login_user_properties[] = {
-        { "UID",                    bus_property_append_uid,         "u", offsetof(User, uid)                 },
-        { "GID",                    bus_property_append_gid,         "u", offsetof(User, gid)                 },
-        { "Name",                   bus_property_append_string,      "s", offsetof(User, name),               true },
-        { "Timestamp",              bus_property_append_usec,        "t", offsetof(User, timestamp.realtime)  },
-        { "TimestampMonotonic",     bus_property_append_usec,        "t", offsetof(User, timestamp.monotonic) },
-        { "RuntimePath",            bus_property_append_string,      "s", offsetof(User, runtime_path),       true },
-        { "Service",                bus_property_append_string,      "s", offsetof(User, service),            true },
-        { "Slice",                  bus_property_append_string,      "s", offsetof(User, slice),              true },
-        { "Display",                bus_user_append_display,      "(so)", 0 },
-        { "State",                  bus_user_append_state,           "s", 0 },
-        { "Sessions",               bus_user_append_sessions,    "a(so)", 0 },
-        { "IdleHint",               bus_user_append_idle_hint,       "b", 0 },
-        { "IdleSinceHint",          bus_user_append_idle_hint_since, "t", 0 },
-        { "IdleSinceHintMonotonic", bus_user_append_idle_hint_since, "t", 0 },
-        { NULL, }
-};
-
-static DBusHandlerResult user_message_dispatch(
-                User *u,
-                DBusConnection *connection,
-                DBusMessage *message) {
-
-        DBusError error;
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+static int method_kill(sd_bus *bus, sd_bus_message *message, void *userdata) {
+        User *u = userdata;
+        int32_t signo;
         int r;
 
-        assert(u);
-        assert(connection);
+        assert(bus);
         assert(message);
+        assert(u);
 
-        if (dbus_message_is_method_call(message, "org.freedesktop.login1.User", "Terminate")) {
-
-                r = user_stop(u);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.User", "Kill")) {
-                int32_t signo;
-
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_INT32, &signo,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
-
-                if (signo <= 0 || signo >= _NSIG)
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
-
-                r = user_kill(u, signo);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
-
-        } else {
-                const BusBoundProperties bps[] = {
-                        { "org.freedesktop.login1.User", bus_login_user_properties, u },
-                        { NULL, }
-                };
-
-                return bus_default_message_handler(connection, message, INTROSPECTION, INTERFACES_LIST, bps);
-        }
-
-        if (reply) {
-                if (!bus_maybe_send_reply(connection, message, reply))
-                        goto oom;
-        }
+        r = sd_bus_message_read(message, "i", &signo);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-        return DBUS_HANDLER_RESULT_HANDLED;
+        if (signo <= 0 || signo >= _NSIG)
+                return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal %i", signo);
 
-oom:
-        dbus_error_free(&error);
+        r = user_kill(u, signo);
+        if (r < 0)
+                return sd_bus_reply_method_errno(bus, message, r, NULL);
 
-        return DBUS_HANDLER_RESULT_NEED_MEMORY;
+        return sd_bus_reply_method_return(bus, message, NULL);
 }
 
-static DBusHandlerResult user_message_handler(
-                DBusConnection *connection,
-                DBusMessage *message,
-                void *userdata) {
+const sd_bus_vtable user_vtable[] = {
+        SD_BUS_VTABLE_START(0),
+
+        SD_BUS_PROPERTY("UID", "u", bus_property_get_uid, offsetof(User, uid), 0),
+        SD_BUS_PROPERTY("GID", "u", bus_property_get_gid, offsetof(User, gid), 0),
+        SD_BUS_PROPERTY("Name", "s", NULL, offsetof(User, name), 0),
+        SD_BUS_PROPERTY("Timestamp", "t", NULL, offsetof(User, timestamp.realtime), 0),
+        SD_BUS_PROPERTY("TimestampMonotonic", "t", NULL, offsetof(User, timestamp.monotonic), 0),
+        SD_BUS_PROPERTY("RuntimePath", "s", NULL, offsetof(User, runtime_path), 0),
+        SD_BUS_PROPERTY("Service", "s", NULL, offsetof(User, service), 0),
+        SD_BUS_PROPERTY("Slice", "s", NULL, offsetof(User, slice), 0),
+        SD_BUS_PROPERTY("Display", "(so)", property_get_display, 0, 0),
+        SD_BUS_PROPERTY("State", "s", property_get_state, 0, 0),
+        SD_BUS_PROPERTY("Sessions", "a(so)", property_get_sessions, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+        SD_BUS_PROPERTY("IdleHint", "b", property_get_idle_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+        SD_BUS_PROPERTY("IdleSinceHint", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+        SD_BUS_PROPERTY("IdleSinceHintMonotonic", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+
+        SD_BUS_METHOD("Terminate", NULL, NULL, method_terminate, 0),
+        SD_BUS_METHOD("Kill", "i", NULL, method_kill, 0),
+
+        SD_BUS_VTABLE_END
+};
 
+int user_object_find(sd_bus *bus, const char *path, const char *interface, void **found, void *userdata) {
+
+        _cleanup_free_ char *e = NULL;
         Manager *m = userdata;
-        User *u;
+        unsigned long lu;
+        const char *p;
+        User *user;
         int r;
 
-        r = get_user_for_path(m, dbus_message_get_path(message), &u);
-        if (r < 0) {
-
-                if (r == -ENOMEM)
-                        return DBUS_HANDLER_RESULT_NEED_MEMORY;
+        assert(bus);
+        assert(path);
+        assert(interface);
+        assert(found);
+        assert(m);
 
-                if (r == -ENOENT) {
-                        DBusError e;
+        p = startswith(path, "/org/freedesktop/login1/user/_");
+        if (!p)
+                return 0;
 
-                        dbus_error_init(&e);
-                        dbus_set_error_const(&e, DBUS_ERROR_UNKNOWN_OBJECT, "Unknown user");
-                        return bus_send_error_reply(connection, message, &e, r);
-                }
+        r = safe_atolu(p, &lu);
+        if (r < 0)
+                return 0;
 
-                return bus_send_error_reply(connection, message, NULL, r);
-        }
+        user = hashmap_get(m->users, ULONG_TO_PTR(lu));
+        if (!user)
+                return 0;
 
-        return user_message_dispatch(u, connection, message);
+        *found = user;
+        return 1;
 }
 
-const DBusObjectPathVTable bus_user_vtable = {
-        .message_function = user_message_handler
-};
-
 char *user_bus_path(User *u) {
         char *s;
 
@@ -336,42 +255,57 @@ char *user_bus_path(User *u) {
         return s;
 }
 
-int user_send_signal(User *u, bool new_user) {
-        _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
-        _cleanup_free_ char *p = NULL;
-        uint32_t uid;
+int user_node_enumerator(sd_bus *bus, const char *path, char ***nodes, void *userdata) {
+        _cleanup_strv_free_ char **l = NULL;
+        Manager *m = userdata;
+        User *user;
+        Iterator i;
+        int r;
 
-        assert(u);
+        assert(bus);
+        assert(path);
+        assert(nodes);
 
-        m = dbus_message_new_signal("/org/freedesktop/login1",
-                                    "org.freedesktop.login1.Manager",
-                                    new_user ? "UserNew" : "UserRemoved");
+        HASHMAP_FOREACH(user, m->users, i) {
+                char *p;
 
-        if (!m)
-                return -ENOMEM;
+                p = user_bus_path(user);
+                if (!p)
+                        return -ENOMEM;
 
-        p = user_bus_path(u);
-        if (!p)
-                return -ENOMEM;
+                r = strv_push(&l, p);
+                if (r < 0) {
+                        free(p);
+                        return r;
+                }
+        }
 
-        uid = u->uid;
+        *nodes = l;
+        l = NULL;
 
-        if (!dbus_message_append_args(
-                            m,
-                            DBUS_TYPE_UINT32, &uid,
-                            DBUS_TYPE_OBJECT_PATH, &p,
-                            DBUS_TYPE_INVALID))
-                return -ENOMEM;
+        return 1;
+}
+
+int user_send_signal(User *u, bool new_user) {
+        _cleanup_free_ char *p = NULL;
 
-        if (!dbus_connection_send(u->manager->bus, m, NULL))
+        assert(u);
+
+        p = user_bus_path(u);
+        if (!p)
                 return -ENOMEM;
 
-        return 0;
+        return sd_bus_emit_signal(
+                        u->manager->bus,
+                        "/org/freedesktop/login1",
+                        "org.freedesktop.login1.Manager",
+                        new_user ? "UserNew" : "UserRemoved",
+                        "uo", (uint32_t) u->uid, p);
 }
 
-int user_send_changed(User *u, const char *properties) {
-        _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
+int user_send_changed(User *u, const char *properties, ...) {
         _cleanup_free_ char *p = NULL;
+        char **l;
 
         assert(u);
 
@@ -382,12 +316,7 @@ int user_send_changed(User *u, const char *properties) {
         if (!p)
                 return -ENOMEM;
 
-        m = bus_properties_changed_new(p, "org.freedesktop.login1.User", properties);
-        if (!m)
-                return -ENOMEM;
-
-        if (!dbus_connection_send(u->manager->bus, m, NULL))
-                return -ENOMEM;
+        l = strv_from_stdarg_alloca(properties);
 
-        return 0;
+        return sd_bus_emit_properties_changed_strv(u->manager->bus, p, "org.freedesktop.login1.User", l);
 }
diff --git a/src/login/logind-user.c b/src/login/logind-user.c
index 54ee1cbed..bfbdfaf54 100644
--- a/src/login/logind-user.c
+++ b/src/login/logind-user.c
@@ -25,13 +25,13 @@
 
 #include "util.h"
 #include "mkdir.h"
-#include "cgroup-util.h"
 #include "hashmap.h"
 #include "strv.h"
 #include "fileio.h"
 #include "special.h"
 #include "unit-name.h"
-#include "dbus-common.h"
+#include "bus-util.h"
+#include "bus-error.h"
 #include "logind-user.h"
 
 User* user_new(Manager *m, uid_t uid, gid_t gid, const char *name) {
@@ -329,15 +329,13 @@ static int user_mkdir_runtime_path(User *u) {
 }
 
 static int user_start_slice(User *u) {
-        DBusError error;
         char *job;
         int r;
 
         assert(u);
 
-        dbus_error_init(&error);
-
         if (!u->slice) {
+                _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
                 char lu[DECIMAL_STR_MAX(unsigned long) + 1], *slice;
                 sprintf(lu, "%lu", (unsigned long) u->uid);
 
@@ -347,9 +345,7 @@ static int user_start_slice(User *u) {
 
                 r = manager_start_unit(u->manager, slice, &error, &job);
                 if (r < 0) {
-                        log_error("Failed to start user slice: %s", bus_error(&error, r));
-                        dbus_error_free(&error);
-
+                        log_error("Failed to start user slice: %s", bus_error_message(&error, r));
                         free(slice);
                 } else {
                         u->slice = slice;
@@ -366,14 +362,12 @@ static int user_start_slice(User *u) {
 }
 
 static int user_start_service(User *u) {
-        DBusError error;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         char *job;
         int r;
 
         assert(u);
 
-        dbus_error_init(&error);
-
         if (!u->service) {
                 char lu[DECIMAL_STR_MAX(unsigned long) + 1], *service;
                 sprintf(lu, "%lu", (unsigned long) u->uid);
@@ -384,9 +378,7 @@ static int user_start_service(User *u) {
 
                 r = manager_start_unit(u->manager, service, &error, &job);
                 if (r < 0) {
-                        log_error("Failed to start user service: %s", bus_error(&error, r));
-                        dbus_error_free(&error);
-
+                        log_error("Failed to start user service: %s", bus_error_message(&error, r));
                         free(service);
                 } else {
                         u->service = service;
@@ -441,21 +433,18 @@ int user_start(User *u) {
 }
 
 static int user_stop_slice(User *u) {
-        DBusError error;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         char *job;
         int r;
 
         assert(u);
 
-        dbus_error_init(&error);
-
         if (!u->slice)
                 return 0;
 
         r = manager_stop_unit(u->manager, u->slice, &error, &job);
         if (r < 0) {
-                log_error("Failed to stop user slice: %s", bus_error(&error, r));
-                dbus_error_free(&error);
+                log_error("Failed to stop user slice: %s", bus_error_message(&error, r));
                 return r;
         }
 
@@ -466,21 +455,18 @@ static int user_stop_slice(User *u) {
 }
 
 static int user_stop_service(User *u) {
-        DBusError error;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         char *job;
         int r;
 
         assert(u);
 
-        dbus_error_init(&error);
-
         if (!u->service)
                 return 0;
 
         r = manager_stop_unit(u->manager, u->service, &error, &job);
         if (r < 0) {
-                log_error("Failed to stop user service: %s", bus_error(&error, r));
-                dbus_error_free(&error);
+                log_error("Failed to stop user service: %s", bus_error_message(&error, r));
                 return r;
         }
 
@@ -602,40 +588,43 @@ int user_get_idle_hint(User *u, dual_timestamp *t) {
 }
 
 static int user_check_linger_file(User *u) {
-        char *p;
-        int r;
+        _cleanup_free_ char *cc = NULL;
+        char *p = NULL;
 
-        if (asprintf(&p, "/var/lib/systemd/linger/%s", u->name) < 0)
+        cc = cescape(u->name);
+        if (!cc)
                 return -ENOMEM;
 
-        r = access(p, F_OK) >= 0;
-        free(p);
+        p = strappenda("/var/lib/systemd/linger/", cc);
 
-        return r;
+        return access(p, F_OK) >= 0;
 }
 
-int user_check_gc(User *u, bool drop_not_started) {
+bool user_check_gc(User *u, bool drop_not_started) {
         assert(u);
 
         if (drop_not_started && !u->started)
-                return 0;
+                return false;
 
         if (u->sessions)
-                return 1;
+                return true;
 
         if (user_check_linger_file(u) > 0)
-                return 1;
+                return true;
 
-        if (u->slice_job || u->service_job)
-                return 1;
+        if (u->slice_job && manager_job_is_active(u->manager, u->slice_job))
+                return true;
+
+        if (u->service_job && manager_job_is_active(u->manager, u->service_job))
+                return true;
 
         if (u->slice && manager_unit_is_active(u->manager, u->slice) != 0)
-                return 1;
+                return true;
 
         if (u->service && manager_unit_is_active(u->manager, u->service) != 0)
-                return 1;
+                return true;
 
-        return 0;
+        return false;
 }
 
 void user_add_to_gc_queue(User *u) {
diff --git a/src/login/logind-user.h b/src/login/logind-user.h
index b9171d345..de7ba6d57 100644
--- a/src/login/logind-user.h
+++ b/src/login/logind-user.h
@@ -69,7 +69,7 @@ struct User {
 
 User* user_new(Manager *m, uid_t uid, gid_t gid, const char *name);
 void user_free(User *u);
-int user_check_gc(User *u, bool drop_not_started);
+bool user_check_gc(User *u, bool drop_not_started);
 void user_add_to_gc_queue(User *u);
 int user_start(User *u);
 int user_stop(User *u);
@@ -80,12 +80,13 @@ int user_save(User *u);
 int user_load(User *u);
 int user_kill(User *u, int signo);
 
+extern const sd_bus_vtable user_vtable[];
+int user_node_enumerator(sd_bus *bus, const char *path, char ***nodes, void *userdata);
+int user_object_find(sd_bus *bus, const char *path, const char *interface, void **found, void *userdata);
 char *user_bus_path(User *s);
 
-extern const DBusObjectPathVTable bus_user_vtable;
-
 int user_send_signal(User *u, bool new_user);
-int user_send_changed(User *u, const char *properties);
+int user_send_changed(User *u, const char *properties, ...) _sentinel_;
 
 const char* user_state_to_string(UserState s) _const_;
 UserState user_state_from_string(const char *s) _pure_;
diff --git a/src/login/logind.c b/src/login/logind.c
index 06db2db6f..e334bebdf 100644
--- a/src/login/logind.c
+++ b/src/login/logind.c
@@ -24,32 +24,26 @@
 #include <fcntl.h>
 #include <string.h>
 #include <unistd.h>
-#include <sys/epoll.h>
 #include <linux/vt.h>
 #include <sys/timerfd.h>
 
-#include <systemd/sd-daemon.h>
-
-#include "logind.h"
-#include "dbus-common.h"
-#include "dbus-loop.h"
+#include "sd-daemon.h"
 #include "strv.h"
 #include "conf-parser.h"
 #include "mkdir.h"
+#include "bus-util.h"
+#include "bus-error.h"
+#include "logind.h"
 
 Manager *manager_new(void) {
         Manager *m;
+        int r;
 
         m = new0(Manager, 1);
         if (!m)
                 return NULL;
 
         m->console_active_fd = -1;
-        m->bus_fd = -1;
-        m->udev_seat_fd = -1;
-        m->udev_vcsa_fd = -1;
-        m->udev_button_fd = -1;
-        m->epoll_fd = -1;
         m->reserve_vt_fd = -1;
 
         m->n_autovts = 6;
@@ -61,7 +55,6 @@ Manager *manager_new(void) {
         m->handle_lid_switch = HANDLE_SUSPEND;
         m->lid_switch_ignore_inhibited = true;
 
-        m->idle_action_fd = -1;
         m->idle_action_usec = 30 * USEC_PER_MINUTE;
         m->idle_action = HANDLE_IGNORE;
         m->idle_action_not_before_usec = now(CLOCK_MONOTONIC);
@@ -72,18 +65,15 @@ Manager *manager_new(void) {
         m->users = hashmap_new(trivial_hash_func, trivial_compare_func);
         m->inhibitors = hashmap_new(string_hash_func, string_compare_func);
         m->buttons = hashmap_new(string_hash_func, string_compare_func);
-        m->busnames = hashmap_new(string_hash_func, string_compare_func);
 
         m->user_units = hashmap_new(string_hash_func, string_compare_func);
         m->session_units = hashmap_new(string_hash_func, string_compare_func);
 
-        m->session_fds = hashmap_new(trivial_hash_func, trivial_compare_func);
-        m->inhibitor_fds = hashmap_new(trivial_hash_func, trivial_compare_func);
-        m->button_fds = hashmap_new(trivial_hash_func, trivial_compare_func);
+        m->busnames = set_new(string_hash_func, string_compare_func);
 
         if (!m->devices || !m->seats || !m->sessions || !m->users || !m->inhibitors || !m->buttons || !m->busnames ||
             !m->user_units || !m->session_units ||
-            !m->session_fds || !m->inhibitor_fds || !m->button_fds) {
+            !m->busnames) {
                 manager_free(m);
                 return NULL;
         }
@@ -100,6 +90,12 @@ Manager *manager_new(void) {
                 return NULL;
         }
 
+        r = sd_event_new(&m->event);
+        if (r < 0) {
+                manager_free(m);
+                return NULL;
+        }
+
         return m;
 }
 
@@ -110,7 +106,6 @@ void manager_free(Manager *m) {
         Seat *s;
         Inhibitor *i;
         Button *b;
-        char *n;
 
         assert(m);
 
@@ -132,23 +127,25 @@ void manager_free(Manager *m) {
         while ((b = hashmap_first(m->buttons)))
                 button_free(b);
 
-        while ((n = hashmap_first(m->busnames)))
-                free(hashmap_remove(m->busnames, n));
-
         hashmap_free(m->devices);
         hashmap_free(m->seats);
         hashmap_free(m->sessions);
         hashmap_free(m->users);
         hashmap_free(m->inhibitors);
         hashmap_free(m->buttons);
-        hashmap_free(m->busnames);
 
         hashmap_free(m->user_units);
         hashmap_free(m->session_units);
 
-        hashmap_free(m->session_fds);
-        hashmap_free(m->inhibitor_fds);
-        hashmap_free(m->button_fds);
+        set_free_free(m->busnames);
+
+        sd_event_source_unref(m->idle_action_event_source);
+
+        sd_event_source_unref(m->console_active_event_source);
+        sd_event_source_unref(m->udev_seat_event_source);
+        sd_event_source_unref(m->udev_device_event_source);
+        sd_event_source_unref(m->udev_vcsa_event_source);
+        sd_event_source_unref(m->udev_button_event_source);
 
         if (m->console_active_fd >= 0)
                 close_nointr_nofail(m->console_active_fd);
@@ -165,24 +162,14 @@ void manager_free(Manager *m) {
         if (m->udev)
                 udev_unref(m->udev);
 
-        if (m->bus) {
-                dbus_connection_flush(m->bus);
-                dbus_connection_close(m->bus);
-                dbus_connection_unref(m->bus);
-        }
-
-        if (m->bus_fd >= 0)
-                close_nointr_nofail(m->bus_fd);
+        bus_verify_polkit_async_registry_free(m->bus, m->polkit_registry);
 
-        if (m->epoll_fd >= 0)
-                close_nointr_nofail(m->epoll_fd);
+        sd_bus_unref(m->bus);
+        sd_event_unref(m->event);
 
         if (m->reserve_vt_fd >= 0)
                 close_nointr_nofail(m->reserve_vt_fd);
 
-        if (m->idle_action_fd >= 0)
-                close_nointr_nofail(m->idle_action_fd);
-
         strv_free(m->kill_only_users);
         strv_free(m->kill_exclude_users);
 
@@ -500,7 +487,8 @@ int manager_enumerate_inhibitors(Manager *m) {
         return r;
 }
 
-int manager_dispatch_seat_udev(Manager *m) {
+static int manager_dispatch_seat_udev(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
+        Manager *m = userdata;
         struct udev_device *d;
         int r;
 
@@ -516,7 +504,8 @@ int manager_dispatch_seat_udev(Manager *m) {
         return r;
 }
 
-static int manager_dispatch_device_udev(Manager *m) {
+static int manager_dispatch_device_udev(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
+        Manager *m = userdata;
         struct udev_device *d;
         int r;
 
@@ -532,7 +521,8 @@ static int manager_dispatch_device_udev(Manager *m) {
         return r;
 }
 
-int manager_dispatch_vcsa_udev(Manager *m) {
+static int manager_dispatch_vcsa_udev(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
+        Manager *m = userdata;
         struct udev_device *d;
         int r = 0;
         const char *name;
@@ -556,7 +546,8 @@ int manager_dispatch_vcsa_udev(Manager *m) {
         return r;
 }
 
-int manager_dispatch_button_udev(Manager *m) {
+static int manager_dispatch_button_udev(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
+        Manager *m = userdata;
         struct udev_device *d;
         int r;
 
@@ -572,9 +563,12 @@ int manager_dispatch_button_udev(Manager *m) {
         return r;
 }
 
-int manager_dispatch_console(Manager *m) {
+static int manager_dispatch_console(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
+        Manager *m = userdata;
+
         assert(m);
         assert(m->seat0);
+        assert(m->console_active_fd == fd);
 
         seat_read_active_vt(m->seat0);
 
@@ -604,178 +598,155 @@ static int manager_reserve_vt(Manager *m) {
         return 0;
 }
 
-static void manager_dispatch_other(Manager *m, int fd) {
-        Session *s;
-        Inhibitor *i;
-        Button *b;
+static int manager_connect_bus(Manager *m) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+        int r;
 
-        assert_se(m);
-        assert_se(fd >= 0);
+        assert(m);
+        assert(!m->bus);
 
-        s = hashmap_get(m->session_fds, INT_TO_PTR(fd + 1));
-        if (s) {
-                assert(s->fifo_fd == fd);
-                session_remove_fifo(s);
-                session_stop(s);
-                return;
+        r = sd_bus_open_system(&m->bus);
+        if (r < 0) {
+                log_error("Failed to connect to system bus: %s", strerror(-r));
+                return r;
         }
 
-        i = hashmap_get(m->inhibitor_fds, INT_TO_PTR(fd + 1));
-        if (i) {
-                assert(i->fifo_fd == fd);
-                inhibitor_stop(i);
-                inhibitor_free(i);
-                return;
+        r = sd_bus_add_object_vtable(m->bus, "/org/freedesktop/login1", "org.freedesktop.login1.Manager", manager_vtable, m);
+        if (r < 0) {
+                log_error("Failed to add manager object vtable: %s", strerror(-r));
+                return r;
         }
 
-        b = hashmap_get(m->button_fds, INT_TO_PTR(fd + 1));
-        if (b) {
-                assert(b->fd == fd);
-                button_process(b);
-                return;
+        r = sd_bus_add_fallback_vtable(m->bus, "/org/freedesktop/login1/seat", "org.freedesktop.login1.Seat", seat_vtable, seat_object_find, m);
+        if (r < 0) {
+                log_error("Failed to add seat object vtable: %s", strerror(-r));
+                return r;
         }
 
-        assert_not_reached("Got event for unknown fd");
-}
-
-static int manager_connect_bus(Manager *m) {
-        DBusError error;
-        int r;
-        struct epoll_event ev = {
-                .events = EPOLLIN,
-                .data.u32 = FD_BUS,
-        };
+        r = sd_bus_add_node_enumerator(m->bus, "/org/freedesktop/login1/seat", seat_node_enumerator, m);
+        if (r < 0) {
+                log_error("Failed to add seat enumerator: %s", strerror(-r));
+                return r;
+        }
 
-        assert(m);
-        assert(!m->bus);
-        assert(m->bus_fd < 0);
+        r = sd_bus_add_fallback_vtable(m->bus, "/org/freedesktop/login1/session", "org.freedesktop.login1.Session", session_vtable, session_object_find, m);
+        if (r < 0) {
+                log_error("Failed to add session object vtable: %s", strerror(-r));
+                return r;
+        }
 
-        dbus_error_init(&error);
+        r = sd_bus_add_node_enumerator(m->bus, "/org/freedesktop/login1/session", session_node_enumerator, m);
+        if (r < 0) {
+                log_error("Failed to add session enumerator: %s", strerror(-r));
+                return r;
+        }
 
-        m->bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
-        if (!m->bus) {
-                log_error("Failed to get system D-Bus connection: %s", bus_error_message(&error));
-                r = -ECONNREFUSED;
-                goto fail;
+        r = sd_bus_add_fallback_vtable(m->bus, "/org/freedesktop/login1/user", "org.freedesktop.login1.User", user_vtable, user_object_find, m);
+        if (r < 0) {
+                log_error("Failed to add user object vtable: %s", strerror(-r));
+                return r;
         }
 
-        if (!dbus_connection_register_object_path(m->bus, "/org/freedesktop/login1", &bus_manager_vtable, m) ||
-            !dbus_connection_register_fallback(m->bus, "/org/freedesktop/login1/seat", &bus_seat_vtable, m) ||
-            !dbus_connection_register_fallback(m->bus, "/org/freedesktop/login1/session", &bus_session_vtable, m) ||
-            !dbus_connection_register_fallback(m->bus, "/org/freedesktop/login1/user", &bus_user_vtable, m) ||
-            !dbus_connection_add_filter(m->bus, bus_message_filter, m, NULL)) {
-                r = log_oom();
-                goto fail;
+        r = sd_bus_add_node_enumerator(m->bus, "/org/freedesktop/login1/user", user_node_enumerator, m);
+        if (r < 0) {
+                log_error("Failed to add user enumerator: %s", strerror(-r));
+                return r;
         }
 
-        dbus_bus_add_match(m->bus,
-                           "type='signal',"
-                           "sender='"DBUS_SERVICE_DBUS"',"
-                           "interface='"DBUS_INTERFACE_DBUS"',"
-                           "member='NameOwnerChanged',"
-                           "path='"DBUS_PATH_DBUS"'",
-                           &error);
-        if (dbus_error_is_set(&error)) {
-                log_error("Failed to add match for NameOwnerChanged: %s", bus_error_message(&error));
-                dbus_error_free(&error);
+        r = sd_bus_add_match(m->bus,
+                             "type='signal',"
+                             "sender='org.freedesktop.DBus',"
+                             "interface='org.freedesktop.DBus',"
+                             "member='NameOwnerChanged',"
+                             "path='/org/freedesktop/DBus'",
+                             match_name_owner_changed, m);
+        if (r < 0) {
+                log_error("Failed to add match for NameOwnerChanged: %s", strerror(-r));
+                return r;
         }
 
-        dbus_bus_add_match(m->bus,
-                           "type='signal',"
-                           "sender='org.freedesktop.systemd1',"
-                           "interface='org.freedesktop.systemd1.Manager',"
-                           "member='JobRemoved',"
-                           "path='/org/freedesktop/systemd1'",
-                           &error);
-        if (dbus_error_is_set(&error)) {
-                log_error("Failed to add match for JobRemoved: %s", bus_error_message(&error));
-                dbus_error_free(&error);
+        r = sd_bus_add_match(m->bus,
+                             "type='signal',"
+                             "sender='org.freedesktop.systemd1',"
+                             "interface='org.freedesktop.systemd1.Manager',"
+                             "member='JobRemoved',"
+                             "path='/org/freedesktop/systemd1'",
+                             match_job_removed, m);
+        if (r < 0) {
+                log_error("Failed to add match for JobRemoved: %s", strerror(-r));
+                return r;
         }
 
-        dbus_bus_add_match(m->bus,
-                           "type='signal',"
-                           "sender='org.freedesktop.systemd1',"
-                           "interface='org.freedesktop.systemd1.Manager',"
-                           "member='UnitRemoved',"
-                           "path='/org/freedesktop/systemd1'",
-                           &error);
-        if (dbus_error_is_set(&error)) {
-                log_error("Failed to add match for UnitRemoved: %s", bus_error_message(&error));
-                dbus_error_free(&error);
+        r = sd_bus_add_match(m->bus,
+                             "type='signal',"
+                             "sender='org.freedesktop.systemd1',"
+                             "interface='org.freedesktop.systemd1.Manager',"
+                             "member='UnitRemoved',"
+                             "path='/org/freedesktop/systemd1'",
+                             match_unit_removed, m);
+        if (r < 0) {
+                log_error("Failed to add match for UnitRemoved: %s", strerror(-r));
+                return r;
         }
 
-        dbus_bus_add_match(m->bus,
-                           "type='signal',"
-                           "sender='org.freedesktop.systemd1',"
-                           "interface='org.freedesktop.DBus.Properties',"
-                           "member='PropertiesChanged'",
-                           &error);
-        if (dbus_error_is_set(&error)) {
-                log_error("Failed to add match for PropertiesChanged: %s", bus_error_message(&error));
-                dbus_error_free(&error);
+        r = sd_bus_add_match(m->bus,
+                             "type='signal',"
+                             "sender='org.freedesktop.systemd1',"
+                             "interface='org.freedesktop.DBus.Properties',"
+                             "member='PropertiesChanged'",
+                             match_properties_changed, m);
+        if (r < 0) {
+                log_error("Failed to add match for PropertiesChanged: %s", strerror(-r));
+                return r;
         }
 
-        dbus_bus_add_match(m->bus,
-                           "type='signal',"
-                           "sender='org.freedesktop.systemd1',"
-                           "interface='org.freedesktop.systemd1.Manager',"
-                           "member='Reloading',"
-                           "path='/org/freedesktop/systemd1'",
-                           &error);
-        if (dbus_error_is_set(&error)) {
-                log_error("Failed to add match for Reloading: %s", bus_error_message(&error));
-                dbus_error_free(&error);
+        r = sd_bus_add_match(m->bus,
+                             "type='signal',"
+                             "sender='org.freedesktop.systemd1',"
+                             "interface='org.freedesktop.systemd1.Manager',"
+                             "member='Reloading',"
+                             "path='/org/freedesktop/systemd1'",
+                             match_reloading, m);
+        if (r < 0) {
+                log_error("Failed to add match for Reloading: %s", strerror(-r));
+                return r;
         }
 
-        r = bus_method_call_with_reply(
+        r = sd_bus_call_method(
                         m->bus,
                         "org.freedesktop.systemd1",
                         "/org/freedesktop/systemd1",
                         "org.freedesktop.systemd1.Manager",
                         "Subscribe",
-                        NULL,
                         &error,
-                        DBUS_TYPE_INVALID);
+                        NULL, NULL);
         if (r < 0) {
-                log_error("Failed to enable subscription: %s", bus_error(&error, r));
-                dbus_error_free(&error);
+                log_error("Failed to enable subscription: %s", bus_error_message(&error, r));
+                return r;
         }
 
-        r = dbus_bus_request_name(m->bus, "org.freedesktop.login1", DBUS_NAME_FLAG_DO_NOT_QUEUE, &error);
-        if (dbus_error_is_set(&error)) {
-                log_error("Failed to register name on bus: %s", bus_error_message(&error));
-                r = -EIO;
-                goto fail;
+        r = sd_bus_request_name(m->bus, "org.freedesktop.login1", SD_BUS_NAME_DO_NOT_QUEUE);
+        if (r < 0) {
+                log_error("Failed to register name: %s", strerror(-r));
+                return r;
         }
 
-        if (r != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)  {
+        if (r != SD_BUS_NAME_PRIMARY_OWNER)  {
                 log_error("Failed to acquire name.");
-                r = -EEXIST;
-                goto fail;
+                return -EEXIST;
         }
 
-        m->bus_fd = bus_loop_open(m->bus);
-        if (m->bus_fd < 0) {
-                r = m->bus_fd;
-                goto fail;
+        r = sd_bus_attach_event(m->bus, m->event, 0);
+        if (r < 0) {
+                log_error("Failed to attach bus to event loop: %s", strerror(-r));
+                return r;
         }
 
-        if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->bus_fd, &ev) < 0)
-                goto fail;
-
         return 0;
-
-fail:
-        dbus_error_free(&error);
-
-        return r;
 }
 
 static int manager_connect_console(Manager *m) {
-        struct epoll_event ev = {
-                .events = 0,
-                .data.u32 = FD_CONSOLE,
-        };
+        int r;
 
         assert(m);
         assert(m->console_active_fd < 0);
@@ -783,10 +754,8 @@ static int manager_connect_console(Manager *m) {
         /* On certain architectures (S390 and Xen, and containers),
            /dev/tty0 does not exist, so don't fail if we can't open
            it. */
-        if (access("/dev/tty0", F_OK) < 0) {
-                m->console_active_fd = -1;
+        if (access("/dev/tty0", F_OK) < 0)
                 return 0;
-        }
 
         m->console_active_fd = open("/sys/class/tty/tty0/active", O_RDONLY|O_NOCTTY|O_CLOEXEC);
         if (m->console_active_fd < 0) {
@@ -800,18 +769,17 @@ static int manager_connect_console(Manager *m) {
                 return -errno;
         }
 
-        if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->console_active_fd, &ev) < 0)
-                return -errno;
+        r = sd_event_add_io(m->event, m->console_active_fd, 0, manager_dispatch_console, m, &m->console_active_event_source);
+        if (r < 0) {
+                log_error("Failed to watch foreground console");
+                return r;
+        }
 
         return 0;
 }
 
 static int manager_connect_udev(Manager *m) {
         int r;
-        struct epoll_event ev = {
-                .events = EPOLLIN,
-                .data.u32 = FD_SEAT_UDEV,
-        };
 
         assert(m);
         assert(!m->udev_seat_monitor);
@@ -831,10 +799,9 @@ static int manager_connect_udev(Manager *m) {
         if (r < 0)
                 return r;
 
-        m->udev_seat_fd = udev_monitor_get_fd(m->udev_seat_monitor);
-
-        if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_seat_fd, &ev) < 0)
-                return -errno;
+        r = sd_event_add_io(m->event, udev_monitor_get_fd(m->udev_seat_monitor), EPOLLIN, manager_dispatch_seat_udev, m, &m->udev_seat_event_source);
+        if (r < 0)
+                return r;
 
         m->udev_device_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
         if (!m->udev_device_monitor)
@@ -856,12 +823,9 @@ static int manager_connect_udev(Manager *m) {
         if (r < 0)
                 return r;
 
-        m->udev_device_fd = udev_monitor_get_fd(m->udev_device_monitor);
-        zero(ev);
-        ev.events = EPOLLIN;
-        ev.data.u32 = FD_DEVICE_UDEV;
-        if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_device_fd, &ev) < 0)
-                return -errno;
+        r = sd_event_add_io(m->event, udev_monitor_get_fd(m->udev_device_monitor), EPOLLIN, manager_dispatch_device_udev, m, &m->udev_device_event_source);
+        if (r < 0)
+                return r;
 
         /* Don't watch keys if nobody cares */
         if (m->handle_power_key != HANDLE_IGNORE ||
@@ -885,13 +849,9 @@ static int manager_connect_udev(Manager *m) {
                 if (r < 0)
                         return r;
 
-                m->udev_button_fd = udev_monitor_get_fd(m->udev_button_monitor);
-
-                zero(ev);
-                ev.events = EPOLLIN;
-                ev.data.u32 = FD_BUTTON_UDEV;
-                if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_button_fd, &ev) < 0)
-                        return -errno;
+                r = sd_event_add_io(m->event, udev_monitor_get_fd(m->udev_button_monitor), EPOLLIN, manager_dispatch_button_udev, m, &m->udev_button_event_source);
+                if (r < 0)
+                        return r;
         }
 
         /* Don't bother watching VCSA devices, if nobody cares */
@@ -909,13 +869,9 @@ static int manager_connect_udev(Manager *m) {
                 if (r < 0)
                         return r;
 
-                m->udev_vcsa_fd = udev_monitor_get_fd(m->udev_vcsa_monitor);
-
-                zero(ev);
-                ev.events = EPOLLIN;
-                ev.data.u32 = FD_VCSA_UDEV;
-                if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_vcsa_fd, &ev) < 0)
-                        return -errno;
+                r = sd_event_add_io(m->event, udev_monitor_get_fd(m->udev_vcsa_monitor), EPOLLIN, manager_dispatch_vcsa_udev, m, &m->udev_vcsa_event_source);
+                if (r < 0)
+                        return r;
         }
 
         return 0;
@@ -932,7 +888,7 @@ void manager_gc(Manager *m, bool drop_not_started) {
                 LIST_REMOVE(gc_queue, m->seat_gc_queue, seat);
                 seat->in_gc_queue = false;
 
-                if (seat_check_gc(seat, drop_not_started) == 0) {
+                if (!seat_check_gc(seat, drop_not_started)) {
                         seat_stop(seat);
                         seat_free(seat);
                 }
@@ -942,7 +898,7 @@ void manager_gc(Manager *m, bool drop_not_started) {
                 LIST_REMOVE(gc_queue, m->session_gc_queue, session);
                 session->in_gc_queue = false;
 
-                if (session_check_gc(session, drop_not_started) == 0) {
+                if (!session_check_gc(session, drop_not_started)) {
                         session_stop(session);
                         session_finalize(session);
                         session_free(session);
@@ -953,7 +909,7 @@ void manager_gc(Manager *m, bool drop_not_started) {
                 LIST_REMOVE(gc_queue, m->user_gc_queue, user);
                 user->in_gc_queue = false;
 
-                if (user_check_gc(user, drop_not_started) == 0) {
+                if (!user_check_gc(user, drop_not_started)) {
                         user_stop(user);
                         user_finalize(user);
                         user_free(user);
@@ -961,26 +917,24 @@ void manager_gc(Manager *m, bool drop_not_started) {
         }
 }
 
-int manager_dispatch_idle_action(Manager *m) {
+static int manager_dispatch_idle_action(sd_event_source *s, uint64_t t, void *userdata) {
+        Manager *m = userdata;
         struct dual_timestamp since;
-        struct itimerspec its = {};
+        usec_t n, elapse;
         int r;
-        usec_t n;
 
         assert(m);
 
         if (m->idle_action == HANDLE_IGNORE ||
-            m->idle_action_usec <= 0) {
-                r = 0;
-                goto finish;
-        }
+            m->idle_action_usec <= 0)
+                return 0;
 
         n = now(CLOCK_MONOTONIC);
 
         r = manager_get_idle_hint(m, &since);
         if (r <= 0)
                 /* Not idle. Let's check if after a timeout it might be idle then. */
-                timespec_store(&its.it_value, n + m->idle_action_usec);
+                elapse = n + m->idle_action_usec;
         else {
                 /* Idle! Let's see if it's time to do something, or if
                  * we shall sleep for longer. */
@@ -993,45 +947,39 @@ int manager_dispatch_idle_action(Manager *m) {
                         m->idle_action_not_before_usec = n;
                 }
 
-                timespec_store(&its.it_value, MAX(since.monotonic, m->idle_action_not_before_usec) + m->idle_action_usec);
+                elapse = MAX(since.monotonic, m->idle_action_not_before_usec) + m->idle_action_usec;
         }
 
-        if (m->idle_action_fd < 0) {
-                struct epoll_event ev = {
-                        .events = EPOLLIN,
-                        .data.u32 = FD_IDLE_ACTION,
-                };
+        if (!m->idle_action_event_source) {
 
-                m->idle_action_fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
-                if (m->idle_action_fd < 0) {
-                        log_error("Failed to create idle action timer: %m");
-                        r = -errno;
-                        goto finish;
+                r = sd_event_add_monotonic(m->event, elapse, USEC_PER_SEC*30, manager_dispatch_idle_action, m, &m->idle_action_event_source);
+                if (r < 0) {
+                        log_error("Failed to add idle event source: %s", strerror(-r));
+                        return r;
                 }
 
-                if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->idle_action_fd, &ev) < 0) {
-                        log_error("Failed to add idle action timer to epoll: %m");
-                        r = -errno;
-                        goto finish;
+                r = sd_event_source_set_priority(m->idle_action_event_source, SD_PRIORITY_IDLE+10);
+                if (r < 0) {
+                        log_error("Failed to set idle event source priority: %s", strerror(-r));
+                        return r;
+                }
+        } else {
+                r = sd_event_source_set_time(m->idle_action_event_source, elapse);
+                if (r < 0) {
+                        log_error("Failed to set idle event timer: %s", strerror(-r));
+                        return r;
                 }
-        }
 
-        if (timerfd_settime(m->idle_action_fd, TFD_TIMER_ABSTIME, &its, NULL) < 0) {
-                log_error("Failed to reset timerfd: %m");
-                r = -errno;
-                goto finish;
+                r = sd_event_source_set_enabled(m->idle_action_event_source, SD_EVENT_ONESHOT);
+                if (r < 0) {
+                        log_error("Failed to enable idle event timer: %s", strerror(-r));
+                        return r;
+                }
         }
 
         return 0;
-
-finish:
-        if (m->idle_action_fd >= 0) {
-                close_nointr_nofail(m->idle_action_fd);
-                m->idle_action_fd = -1;
-        }
-
-        return r;
 }
+
 int manager_startup(Manager *m) {
         int r;
         Seat *seat;
@@ -1041,11 +989,6 @@ int manager_startup(Manager *m) {
         Iterator i;
 
         assert(m);
-        assert(m->epoll_fd <= 0);
-
-        m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
-        if (m->epoll_fd < 0)
-                return -errno;
 
         /* Connect to console */
         r = manager_connect_console(m);
@@ -1054,8 +997,10 @@ int manager_startup(Manager *m) {
 
         /* Connect to udev */
         r = manager_connect_udev(m);
-        if (r < 0)
+        if (r < 0) {
+                log_error("Failed to create udev watchers: %s", strerror(-r));
                 return r;
+        }
 
         /* Connect to the bus */
         r = manager_connect_bus(m);
@@ -1064,8 +1009,10 @@ int manager_startup(Manager *m) {
 
         /* Instantiate magic seat 0 */
         r = manager_add_seat(m, "seat0", &m->seat0);
-        if (r < 0)
+        if (r < 0) {
+                log_error("Failed to add seat0: %s", strerror(-r));
                 return r;
+        }
 
         /* Deserialize state */
         r = manager_enumerate_devices(m);
@@ -1111,7 +1058,7 @@ int manager_startup(Manager *m) {
         HASHMAP_FOREACH(inhibitor, m->inhibitors, i)
                 inhibitor_start(inhibitor);
 
-        manager_dispatch_idle_action(m);
+        manager_dispatch_idle_action(NULL, 0, m);
 
         return 0;
 }
@@ -1137,12 +1084,18 @@ static int manager_recheck_buttons(Manager *m) {
 }
 
 int manager_run(Manager *m) {
+        int r;
+
         assert(m);
 
         for (;;) {
-                struct epoll_event event;
-                int n;
-                int msec = -1;
+                usec_t us = (uint64_t) -1;
+
+                r = sd_event_get_state(m->event);
+                if (r < 0)
+                        return r;
+                if (r == SD_EVENT_FINISHED)
+                        return 0;
 
                 manager_gc(m, true);
 
@@ -1152,66 +1105,18 @@ int manager_run(Manager *m) {
                 if (manager_recheck_buttons(m) > 0)
                         continue;
 
-                if (dbus_connection_dispatch(m->bus) != DBUS_DISPATCH_COMPLETE)
-                        continue;
-
-                manager_gc(m, true);
-
                 if (m->action_what != 0 && !m->action_job) {
                         usec_t x, y;
 
                         x = now(CLOCK_MONOTONIC);
                         y = m->action_timestamp + m->inhibit_delay_max;
 
-                        msec = x >= y ? 0 : (int) ((y - x) / USEC_PER_MSEC);
+                        us = x >= y ? 0 : y - x;
                 }
 
-                n = epoll_wait(m->epoll_fd, &event, 1, msec);
-                if (n < 0) {
-                        if (errno == EINTR || errno == EAGAIN)
-                                continue;
-
-                        log_error("epoll() failed: %m");
-                        return -errno;
-                }
-
-                if (n == 0)
-                        continue;
-
-                switch (event.data.u32) {
-
-                case FD_SEAT_UDEV:
-                        manager_dispatch_seat_udev(m);
-                        break;
-
-                case FD_DEVICE_UDEV:
-                        manager_dispatch_device_udev(m);
-                        break;
-
-                case FD_VCSA_UDEV:
-                        manager_dispatch_vcsa_udev(m);
-                        break;
-
-                case FD_BUTTON_UDEV:
-                        manager_dispatch_button_udev(m);
-                        break;
-
-                case FD_CONSOLE:
-                        manager_dispatch_console(m);
-                        break;
-
-                case FD_IDLE_ACTION:
-                        manager_dispatch_idle_action(m);
-                        break;
-
-                case FD_BUS:
-                        bus_loop_dispatch(m->bus_fd);
-                        break;
-
-                default:
-                        if (event.data.u32 >= FD_OTHER_BASE)
-                                manager_dispatch_other(m, event.data.u32 - FD_OTHER_BASE);
-                }
+                r = sd_event_run(m->event, us);
+                if (r < 0)
+                        return r;
         }
 
         return 0;
diff --git a/src/login/logind.h b/src/login/logind.h
index 9e6296cb7..9a3b9a832 100644
--- a/src/login/logind.h
+++ b/src/login/logind.h
@@ -23,14 +23,14 @@
 
 #include <stdbool.h>
 #include <inttypes.h>
-#include <dbus/dbus.h>
 #include <libudev.h>
 
+#include "sd-event.h"
+#include "sd-bus.h"
 #include "util.h"
-#include "audit.h"
 #include "list.h"
 #include "hashmap.h"
-#include "cgroup-util.h"
+#include "set.h"
 
 typedef struct Manager Manager;
 
@@ -43,7 +43,8 @@ typedef struct Manager Manager;
 #include "logind-action.h"
 
 struct Manager {
-        DBusConnection *bus;
+        sd_event *event;
+        sd_bus *bus;
 
         Hashmap *devices;
         Hashmap *seats;
@@ -51,7 +52,8 @@ struct Manager {
         Hashmap *users;
         Hashmap *inhibitors;
         Hashmap *buttons;
-        Hashmap *busnames;
+
+        Set *busnames;
 
         LIST_HEAD(Seat, seat_gc_queue);
         LIST_HEAD(Session, session_gc_queue);
@@ -60,14 +62,13 @@ struct Manager {
         struct udev *udev;
         struct udev_monitor *udev_seat_monitor, *udev_device_monitor, *udev_vcsa_monitor, *udev_button_monitor;
 
-        int udev_seat_fd;
-        int udev_device_fd;
-        int udev_vcsa_fd;
-        int udev_button_fd;
+        sd_event_source *console_active_event_source;
+        sd_event_source *udev_seat_event_source;
+        sd_event_source *udev_device_event_source;
+        sd_event_source *udev_vcsa_event_source;
+        sd_event_source *udev_button_event_source;
 
         int console_active_fd;
-        int bus_fd;
-        int epoll_fd;
 
         unsigned n_autovts;
 
@@ -85,10 +86,6 @@ struct Manager {
         Hashmap *session_units;
         Hashmap *user_units;
 
-        Hashmap *session_fds;
-        Hashmap *inhibitor_fds;
-        Hashmap *button_fds;
-
         usec_t inhibit_delay_max;
 
         /* If an action is currently being executed or is delayed,
@@ -105,7 +102,7 @@ struct Manager {
         char *action_job;
         usec_t action_timestamp;
 
-        int idle_action_fd; /* the timer_fd */
+        sd_event_source *idle_action_event_source;
         usec_t idle_action_usec;
         usec_t idle_action_not_before_usec;
         HandleAction idle_action;
@@ -119,17 +116,8 @@ struct Manager {
         bool suspend_key_ignore_inhibited;
         bool hibernate_key_ignore_inhibited;
         bool lid_switch_ignore_inhibited;
-};
 
-enum {
-        FD_SEAT_UDEV,
-        FD_DEVICE_UDEV,
-        FD_VCSA_UDEV,
-        FD_BUTTON_UDEV,
-        FD_CONSOLE,
-        FD_BUS,
-        FD_IDLE_ACTION,
-        FD_OTHER_BASE
+        Hashmap *polkit_registry;
 };
 
 Manager *manager_new(void);
@@ -147,12 +135,6 @@ int manager_add_inhibitor(Manager *m, const char* id, Inhibitor **_inhibitor);
 int manager_process_seat_device(Manager *m, struct udev_device *d);
 int manager_process_button_device(Manager *m, struct udev_device *d);
 
-int manager_dispatch_seat_udev(Manager *m);
-int manager_dispatch_vcsa_udev(Manager *m);
-int manager_dispatch_button_udev(Manager *m);
-int manager_dispatch_console(Manager *m);
-int manager_dispatch_idle_action(Manager *m);
-
 int manager_enumerate_devices(Manager *m);
 int manager_enumerate_buttons(Manager *m);
 int manager_enumerate_seats(Manager *m);
@@ -173,21 +155,26 @@ int manager_get_idle_hint(Manager *m, dual_timestamp *t);
 int manager_get_user_by_pid(Manager *m, pid_t pid, User **user);
 int manager_get_session_by_pid(Manager *m, pid_t pid, Session **session);
 
-extern const DBusObjectPathVTable bus_manager_vtable;
+extern const sd_bus_vtable manager_vtable[];
 
-DBusHandlerResult bus_message_filter(DBusConnection *c, DBusMessage *message, void *userdata);
+int match_job_removed(sd_bus *bus, sd_bus_message *message, void *userdata);
+int match_unit_removed(sd_bus *bus, sd_bus_message *message, void *userdata);
+int match_properties_changed(sd_bus *bus, sd_bus_message *message, void *userdata);
+int match_reloading(sd_bus *bus, sd_bus_message *message, void *userdata);
+int match_name_owner_changed(sd_bus *bus, sd_bus_message *message, void *userdata);
 
-int bus_manager_shutdown_or_sleep_now_or_later(Manager *m, const char *unit_name, InhibitWhat w, DBusError *error);
+int bus_manager_shutdown_or_sleep_now_or_later(Manager *m, const char *unit_name, InhibitWhat w, sd_bus_error *error);
 
-int manager_send_changed(Manager *manager, const char *properties);
+int manager_send_changed(Manager *manager, const char *property, ...) _sentinel_;
 
 int manager_dispatch_delayed(Manager *manager);
 
-int manager_start_scope(Manager *manager, const char *scope, pid_t pid, const char *slice, const char *description, const char *after, const char *kill_mode, DBusError *error, char **job);
-int manager_start_unit(Manager *manager, const char *unit, DBusError *error, char **job);
-int manager_stop_unit(Manager *manager, const char *unit, DBusError *error, char **job);
-int manager_kill_unit(Manager *manager, const char *unit, KillWho who, int signo, DBusError *error);
+int manager_start_scope(Manager *manager, const char *scope, pid_t pid, const char *slice, const char *description, const char *after, const char *kill_mode, sd_bus_error *error, char **job);
+int manager_start_unit(Manager *manager, const char *unit, sd_bus_error *error, char **job);
+int manager_stop_unit(Manager *manager, const char *unit, sd_bus_error *error, char **job);
+int manager_kill_unit(Manager *manager, const char *unit, KillWho who, int signo, sd_bus_error *error);
 int manager_unit_is_active(Manager *manager, const char *unit);
+int manager_job_is_active(Manager *manager, const char *path);
 
 /* gperf lookup function */
 const struct ConfigPerfItem* logind_gperf_lookup(const char *key, unsigned length);
diff --git a/src/login/pam-module.c b/src/login/pam-module.c
index 973daf703..81ec15f93 100644
--- a/src/login/pam-module.c
+++ b/src/login/pam-module.c
@@ -187,7 +187,7 @@ _public_ PAM_EXTERN int pam_sm_open_session(
         const char *username, *id, *object_path, *runtime_path, *service = NULL, *tty = NULL, *display = NULL, *remote_user = NULL, *remote_host = NULL, *seat = NULL, *type = NULL, *class = NULL, *class_pam = NULL, *cvtnr = NULL;
         DBusError error;
         uint32_t uid, pid;
-        DBusMessageIter iter;
+        DBusMessageIter iter, sub;
         int session_fd = -1;
         DBusConnection *bus = NULL;
         DBusMessage *m = NULL, *reply = NULL;
@@ -372,6 +372,13 @@ _public_ PAM_EXTERN int pam_sm_open_session(
 
         dbus_message_iter_init_append(m, &iter);
 
+        if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(sv)", &sub) ||
+            !dbus_message_iter_close_container(&iter, &sub)) {
+                pam_syslog(handle, LOG_ERR, "Could not attach parameters to message.");
+                r = PAM_BUF_ERR;
+                goto finish;
+        }
+
         if (debug)
                 pam_syslog(handle, LOG_DEBUG, "Asking logind to create session: "
                            "uid=%u pid=%u service=%s type=%s class=%s seat=%s vtnr=%u tty=%s display=%s remote=%s remote_user=%s remote_host=%s",