chiark / gitweb /
treewide: use log_*_errno whenever %m is in the format string
[elogind.git] / src / login / logind-dbus.c
index 68e499f..d412311 100644 (file)
 #include <string.h>
 #include <unistd.h>
 #include <pwd.h>
+#include <sys/capability.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 "systemd/sd-id128.h"
-#include "systemd/sd-messages.h"
+#include "sleep-config.h"
 #include "fileio-label.h"
 #include "label.h"
+#include "utf8.h"
+#include "unit-name.h"
+#include "virt.h"
+#include "audit.h"
+#include "bus-util.h"
+#include "bus-error.h"
+#include "logind.h"
+#include "bus-errors.h"
+#include "udev-util.h"
+
+static int property_get_idle_hint(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                void *userdata,
+                sd_bus_error *error) {
 
-#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=\"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=\"controllers\" type=\"as\" direction=\"in\"/>\n" \
-        "   <arg name=\"reset_controllers\" type=\"as\" direction=\"in\"/>\n" \
-        "   <arg name=\"kill_processes\" type=\"b\" 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=\"ControlGroupHierarchy\" type=\"s\" access=\"read\"/>\n" \
-        "  <property name=\"Controllers\" type=\"as\" access=\"read\"/>\n" \
-        "  <property name=\"ResetControllers\" type=\"as\" access=\"read\"/>\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);
+        Manager *m = userdata;
 
-        b = manager_get_idle_hint(m, NULL) > 0;
-        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
-                return -ENOMEM;
+        assert(bus);
+        assert(reply);
+        assert(m);
 
-        return 0;
+        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,
+                void *userdata,
+                sd_bus_error *error) {
+
+        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,
+                void *userdata,
+                sd_bus_error *error) {
+
+        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,
+                void *userdata,
+                sd_bus_error *error) {
+
+        Manager *m = userdata;
+        bool b;
 
-        assert(i);
-        assert(property);
+        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, DBusMessage **_reply) {
-        const char *type, *class, *cseat, *tty, *display, *remote_user, *remote_host, *service;
-        uint32_t uid, leader, audit_id = 0;
-        dbus_bool_t remote, kill_processes, exists;
-        _cleanup_strv_free_ char **controllers = NULL, **reset_controllers = NULL;
-        _cleanup_free_ char *cgroup = NULL, *id = NULL, *p = NULL;
-        SessionType t;
-        SessionClass c;
-        DBusMessageIter iter;
+static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_handle_action, handle_action, HandleAction);
+
+static int method_get_session(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        _cleanup_free_ char *p = NULL;
+        Manager *m = userdata;
+        const char *name;
+        Session *session;
         int r;
-        uint32_t vtnr = 0;
-        _cleanup_close_ int 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 r;
+
+        session = hashmap_get(m->sessions, name);
+        if (!session)
+                return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", name);
+
+        p = session_bus_path(session);
+        if (!p)
+                return -ENOMEM;
+
+        return sd_bus_reply_method_return(message, "o", p);
+}
+
+static int method_get_session_by_pid(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        _cleanup_free_ char *p = NULL;
         Session *session = NULL;
+        Manager *m = userdata;
+        pid_t pid;
+        int r;
+
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        assert_cc(sizeof(pid_t) == sizeof(uint32_t));
+
+        r = sd_bus_message_read(message, "u", &pid);
+        if (r < 0)
+                return r;
+
+        if (pid == 0) {
+                _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
+
+                r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
+                if (r < 0)
+                        return r;
+
+                r = sd_bus_creds_get_pid(creds, &pid);
+                if (r < 0)
+                        return r;
+        }
+
+        r = manager_get_session_by_pid(m, pid, &session);
+        if (r < 0)
+                return r;
+        if (!session)
+                return sd_bus_error_setf(error, BUS_ERROR_NO_SESSION_FOR_PID, "PID "PID_FMT" does not belong to any known session", pid);
+
+        p = session_bus_path(session);
+        if (!p)
+                return -ENOMEM;
+
+        return sd_bus_reply_method_return(message, "o", p);
+}
+
+static int method_get_user(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        _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 r;
+
+        user = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
+        if (!user)
+                return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_USER, "No user "UID_FMT" known or logged in", uid);
+
+        p = user_bus_path(user);
+        if (!p)
+                return -ENOMEM;
+
+        return sd_bus_reply_method_return(message, "o", p);
+}
+
+static int method_get_user_by_pid(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        _cleanup_free_ char *p = NULL;
+        Manager *m = userdata;
         User *user = NULL;
-        Seat *seat = NULL;
-        bool b;
+        pid_t pid;
+        int r;
+
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        assert_cc(sizeof(pid_t) == sizeof(uint32_t));
+
+        r = sd_bus_message_read(message, "u", &pid);
+        if (r < 0)
+                return r;
+
+        if (pid == 0) {
+                _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
+
+                r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
+                if (r < 0)
+                        return r;
+
+                r = sd_bus_creds_get_pid(creds, &pid);
+                if (r < 0)
+                        return r;
+        }
+
+        r = manager_get_user_by_pid(m, pid, &user);
+        if (r < 0)
+                return r;
+        if (!user)
+                return sd_bus_error_setf(error, BUS_ERROR_NO_USER_FOR_PID, "PID "PID_FMT" does not belong to any known or logged in user", pid);
+
+        p = user_bus_path(user);
+        if (!p)
+                return -ENOMEM;
 
+        return sd_bus_reply_method_return(message, "o", p);
+}
+
+static int method_get_seat(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        _cleanup_free_ char *p = NULL;
+        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 r;
+
+        seat = hashmap_get(m->seats, name);
+        if (!seat)
+                return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_SEAT, "No seat '%s' known", name);
+
+        p = seat_bus_path(seat);
+        if (!p)
+                return -ENOMEM;
+
+        return sd_bus_reply_method_return(message, "o", p);
+}
+
+static int method_list_sessions(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        Manager *m = userdata;
+        Session *session;
+        Iterator i;
+        int r;
+
+        assert(bus);
         assert(message);
-        assert(_reply);
+        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_new_method_return(message, &reply);
+        if (r < 0)
+                return r;
 
-        dbus_message_iter_get_basic(&iter, &uid);
+        r = sd_bus_message_open_container(reply, 'a', "(susso)");
+        if (r < 0)
+                return r;
 
-        if (!dbus_message_iter_next(&iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32)
-                return -EINVAL;
+        HASHMAP_FOREACH(session, m->sessions, i) {
+                _cleanup_free_ char *p = NULL;
+
+                p = session_bus_path(session);
+                if (!p)
+                        return -ENOMEM;
+
+                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 r;
+        }
 
-        dbus_message_iter_get_basic(&iter, &leader);
+        r = sd_bus_message_close_container(reply);
+        if (r < 0)
+                return r;
 
-        if (leader <= 0 ||
-            !dbus_message_iter_next(&iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
-                return -EINVAL;
+        return sd_bus_send(bus, reply, NULL);
+}
 
-        dbus_message_iter_get_basic(&iter, &service);
+static int method_list_users(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        Manager *m = userdata;
+        User *user;
+        Iterator i;
+        int r;
 
-        if (!dbus_message_iter_next(&iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
-                return -EINVAL;
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        r = sd_bus_message_new_method_return(message, &reply);
+        if (r < 0)
+                return r;
+
+        r = sd_bus_message_open_container(reply, 'a', "(uso)");
+        if (r < 0)
+                return r;
+
+        HASHMAP_FOREACH(user, m->users, i) {
+                _cleanup_free_ char *p = NULL;
+
+                p = user_bus_path(user);
+                if (!p)
+                        return -ENOMEM;
+
+                r = sd_bus_message_append(reply, "(uso)",
+                                          (uint32_t) user->uid,
+                                          user->name,
+                                          p);
+                if (r < 0)
+                        return r;
+        }
+
+        r = sd_bus_message_close_container(reply);
+        if (r < 0)
+                return r;
+
+        return sd_bus_send(bus, reply, NULL);
+}
+
+static int method_list_seats(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        _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(message, &reply);
+        if (r < 0)
+                return r;
+
+        r = sd_bus_message_open_container(reply, 'a', "(so)");
+        if (r < 0)
+                return r;
+
+        HASHMAP_FOREACH(seat, m->seats, i) {
+                _cleanup_free_ char *p = NULL;
+
+                p = seat_bus_path(seat);
+                if (!p)
+                        return -ENOMEM;
+
+                r = sd_bus_message_append(reply, "(so)", seat->id, p);
+                if (r < 0)
+                        return r;
+        }
+
+        r = sd_bus_message_close_container(reply);
+        if (r < 0)
+                return r;
+
+        return sd_bus_send(bus, reply, NULL);
+}
+
+static int method_list_inhibitors(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        _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(message, &reply);
+        if (r < 0)
+                return r;
+
+        r = sd_bus_message_open_container(reply, 'a', "(ssssuu)");
+        if (r < 0)
+                return r;
+
+        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 r;
+        }
+
+        r = sd_bus_message_close_container(reply);
+        if (r < 0)
+                return r;
+
+        return sd_bus_send(bus, reply, NULL);
+}
+
+static int method_create_session(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        const char *service, *type, *class, *cseat, *tty, *display, *remote_user, *remote_host, *desktop;
+        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, "uusssssussbss", &uid, &leader, &service, &type, &class, &desktop, &cseat, &vtnr, &tty, &display, &remote, &remote_user, &remote_host);
+        if (r < 0)
+                return r;
+
+        if (leader == 1)
+                return sd_bus_error_setf(error, 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_error_setf(error, 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_error_setf(error, 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(desktop))
+                desktop = NULL;
+        else {
+                if (!string_is_safe(desktop))
+                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid desktop string %s", desktop);
+        }
 
         if (isempty(cseat))
                 seat = NULL;
         else {
                 seat = hashmap_get(m->seats, cseat);
                 if (!seat)
-                        return -ENOENT;
+                        return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_SEAT, "No seat '%s' known", cseat);
         }
 
-        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->vtconsole;
-                else if (seat != m->vtconsole)
-                        return -EINVAL;
+                        seat = m->seat0;
+                else if (seat != m->seat0)
+                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "TTY %s is virtual console but seat %s is not seat0", tty, seat->id);
 
                 v = vtnr_from_tty(tty);
-
                 if (v <= 0)
-                        return v < 0 ? v : -EINVAL;
+                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Cannot determine VT number from virtual console TTY %s", tty);
 
-                if (vtnr <= 0)
+                if (!vtnr)
                         vtnr = (uint32_t) v;
                 else if (vtnr != (uint32_t) v)
-                        return -EINVAL;
+                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Specified TTY and VT number do not match");
+
         } else if (tty_is_console(tty)) {
 
                 if (!seat)
-                        seat = m->vtconsole;
-                else if (seat != m->vtconsole)
-                        return -EINVAL;
+                        seat = m->seat0;
+                else if (seat != m->seat0)
+                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Console TTY specified but seat is not seat0");
 
                 if (vtnr != 0)
-                        return -EINVAL;
+                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Console TTY specified but VT number is not 0");
         }
 
         if (seat) {
-                if (seat_can_multi_session(seat)) {
-                        if (vtnr > 63)
-                                return -EINVAL;
+                if (seat_has_vts(seat)) {
+                        if (!vtnr || vtnr > 63)
+                                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "VT number out of range");
                 } else {
                         if (vtnr != 0)
-                                return -EINVAL;
+                                return sd_bus_error_setf(error, 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 r;
 
         if (t == _SESSION_TYPE_INVALID) {
                 if (!isempty(display))
@@ -458,124 +557,79 @@ static int bus_manager_create_session(Manager *m, DBusMessage *message, DBusMess
         }
 
         if (c == _SESSION_CLASS_INVALID) {
-                if (!isempty(display) || !isempty(tty))
-                        c = SESSION_USER;
-                else
+                if (t == SESSION_UNSPECIFIED)
                         c = SESSION_BACKGROUND;
+                else
+                        c = SESSION_USER;
         }
 
-        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 (!dbus_message_iter_next(&iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
-            dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRING)
-                return -EINVAL;
+        if (leader <= 0) {
+                _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
 
-        r = bus_parse_strv_iter(&iter, &controllers);
-        if (r < 0)
-                return -EINVAL;
-
-        if (!dbus_message_iter_next(&iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
-            dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRING) {
-                r = -EINVAL;
-                goto fail;
-        }
+                r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
+                if (r < 0)
+                        return r;
 
-        r = bus_parse_strv_iter(&iter, &reset_controllers);
-        if (r < 0)
-                goto fail;
+                assert_cc(sizeof(uint32_t) == sizeof(pid_t));
 
-        if (!dbus_message_iter_next(&iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BOOLEAN) {
-                r = -EINVAL;
-                goto fail;
+                r = sd_bus_creds_get_pid(creds, (pid_t*) &leader);
+                if (r < 0)
+                        return r;
         }
 
-        dbus_message_iter_get_basic(&iter, &kill_processes);
-
-        r = cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, leader, &cgroup);
-        if (r < 0)
-                goto fail;
-
-        r = manager_get_session_by_cgroup(m, cgroup, &session);
-        if (r < 0)
-                goto fail;
-
+        manager_get_session_by_pid(m, leader, &session);
         if (session) {
-                fifo_fd = session_create_fifo(session);
-                if (fifo_fd < 0) {
-                        r = fifo_fd;
-                        goto fail;
-                }
+                _cleanup_free_ char *path = NULL;
+                _cleanup_close_ int fifo_fd = -1;
 
                 /* Session already exists, client is probably
-                 * something like "su" which changes uid but
-                 * is still the same audit session */
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply) {
-                        r = -ENOMEM;
-                        goto fail;
-                }
-
-                p = session_bus_path(session);
-                if (!p) {
-                        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, &p,
-                                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;
-                }
+                 * something like "su" which changes uid but is still
+                 * the same session */
 
-                *_reply = reply;
-                reply = NULL;
+                fifo_fd = session_create_fifo(session);
+                if (fifo_fd < 0)
+                        return fifo_fd;
 
-                return 0;
+                path = session_bus_path(session);
+                if (!path)
+                        return -ENOMEM;
+
+                log_debug("Sending reply about an existing session: "
+                          "id=%s object_path=%s uid=%u runtime_path=%s "
+                          "session_fd=%d seat=%s vtnr=%u",
+                          session->id,
+                          path,
+                          (uint32_t) session->user->uid,
+                          session->user->runtime_path,
+                          fifo_fd,
+                          session->seat ? session->seat->id : "",
+                          (uint32_t) session->vtnr);
+
+                return sd_bus_reply_method_return(
+                                message, "soshusub",
+                                session->id,
+                                path,
+                                session->user->runtime_path,
+                                fifo_fd,
+                                (uint32_t) session->user->uid,
+                                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, "%"PRIu32, audit_id) < 0)
+                        return -ENOMEM;
 
                 /* Wut? There's already a session by this name and we
                  * didn't find it above? Weird, then let's not trust
                  * the audit data and let's better register a new
                  * ID */
                 if (hashmap_get(m->sessions, id)) {
+                        log_warning("Existing logind session ID %s used by new audit session, ignoring", id);
                         audit_id = 0;
 
                         free(id);
@@ -588,10 +642,8 @@ static int bus_manager_create_session(Manager *m, DBusMessage *message, DBusMess
                         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 -ENOMEM;
 
                 } while (hashmap_get(m->sessions, id));
         }
@@ -600,22 +652,19 @@ static int bus_manager_create_session(Manager *m, DBusMessage *message, DBusMess
         if (r < 0)
                 goto fail;
 
-        r = manager_add_session(m, user, id, &session);
+        r = manager_add_session(m, id, &session);
         if (r < 0)
                 goto fail;
 
+        session_set_user(session, user);
+
         session->leader = leader;
         session->audit_id = audit_id;
         session->type = t;
         session->class = c;
         session->remote = remote;
-        session->kill_processes = kill_processes;
         session->vtnr = vtnr;
 
-        session->controllers = cg_shorten_controllers(controllers);
-        session->reset_controllers = cg_shorten_controllers(reset_controllers);
-        controllers = reset_controllers = NULL;
-
         if (!isempty(tty)) {
                 session->tty = strdup(tty);
                 if (!session->tty) {
@@ -656,10 +705,12 @@ static int bus_manager_create_session(Manager *m, DBusMessage *message, DBusMess
                 }
         }
 
-        fifo_fd = session_create_fifo(session);
-        if (fifo_fd < 0) {
-                r = fifo_fd;
-                goto fail;
+        if (!isempty(desktop)) {
+                session->desktop = strdup(desktop);
+                if (!session->desktop) {
+                        r = -ENOMEM;
+                        goto fail;
+                }
         }
 
         if (seat) {
@@ -672,256 +723,400 @@ static int bus_manager_create_session(Manager *m, DBusMessage *message, DBusMess
         if (r < 0)
                 goto fail;
 
-        reply = dbus_message_new_method_return(message);
-        if (!reply) {
-                r = -ENOMEM;
-                goto fail;
-        }
+        session->create_message = sd_bus_message_ref(message);
 
-        p = session_bus_path(session);
-        if (!p) {
-                r = -ENOMEM;
-                goto fail;
-        }
+        /* Now, let's wait until the slice unit and stuff got
+         * created. We send the reply back from
+         * session_send_create_reply().*/
 
-        cseat = seat ? seat->id : "";
-        exists = false;
-        b = dbus_message_append_args(
-                        reply,
-                        DBUS_TYPE_STRING, &session->id,
-                        DBUS_TYPE_OBJECT_PATH, &p,
-                        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;
+        return 1;
+
+fail:
+        if (session)
+                session_add_to_gc_queue(session);
+
+        if (user)
+                user_add_to_gc_queue(user);
+
+        return r;
+}
+
+static int method_release_session(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        Manager *m = userdata;
+        Session *session;
+        const char *name;
+        int r;
+
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        r = sd_bus_message_read(message, "s", &name);
+        if (r < 0)
+                return r;
+
+        session = hashmap_get(m->sessions, name);
+        if (!session)
+                return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", name);
+
+        session_release(session);
+
+        return sd_bus_reply_method_return(message, NULL);
+}
+
+static int method_activate_session(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        Manager *m = userdata;
+        Session *session;
+        const char *name;
+        int r;
+
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        r = sd_bus_message_read(message, "s", &name);
+        if (r < 0)
+                return r;
+
+        session = hashmap_get(m->sessions, name);
+        if (!session)
+                return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", name);
+
+        r = session_activate(session);
+        if (r < 0)
+                return r;
+
+        return sd_bus_reply_method_return(message, NULL);
+}
+
+static int method_activate_session_on_seat(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        const char *session_name, *seat_name;
+        Manager *m = userdata;
+        Session *session;
+        Seat *seat;
+        int r;
+
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        /* Same as ActivateSession() but refuses to work if
+         * the seat doesn't match */
+
+        r = sd_bus_message_read(message, "ss", &session_name, &seat_name);
+        if (r < 0)
+                return r;
+
+        session = hashmap_get(m->sessions, session_name);
+        if (!session)
+                return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", session_name);
+
+        seat = hashmap_get(m->seats, seat_name);
+        if (!seat)
+                return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_SEAT, "No seat '%s' known", seat_name);
+
+        if (session->seat != seat)
+                return sd_bus_error_setf(error, BUS_ERROR_SESSION_NOT_ON_SEAT, "Session %s not on seat %s", session_name, seat_name);
+
+        r = session_activate(session);
+        if (r < 0)
+                return r;
+
+        return sd_bus_reply_method_return(message, NULL);
+}
+
+static int method_lock_session(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        Manager *m = userdata;
+        Session *session;
+        const char *name;
+        int r;
+
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        r = sd_bus_message_read(message, "s", &name);
+        if (r < 0)
+                return r;
+
+        session = hashmap_get(m->sessions, name);
+        if (!session)
+                return sd_bus_error_setf(error, 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)
+                return r;
+
+        return sd_bus_reply_method_return(message, NULL);
+}
+
+static int method_lock_sessions(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        Manager *m = userdata;
+        int r;
+
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        r = session_send_lock_all(m, streq(sd_bus_message_get_member(message), "LockSessions"));
+        if (r < 0)
+                return r;
+
+        return sd_bus_reply_method_return(message, NULL);
+}
+
+static int method_kill_session(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        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 r;
+
+        if (isempty(swho))
+                who = KILL_ALL;
+        else {
+                who = kill_who_from_string(swho);
+                if (who < 0)
+                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid kill parameter '%s'", swho);
         }
 
-        *_reply = reply;
-        reply = NULL;
+        if (signo <= 0 || signo >= _NSIG)
+                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal %i", signo);
+
+        session = hashmap_get(m->sessions, name);
+        if (!session)
+                return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", name);
+
+        r = session_kill(session, who, signo);
+        if (r < 0)
+                return r;
+
+        return sd_bus_reply_method_return(message, NULL);
+}
+
+static int method_kill_user(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        Manager *m = userdata;
+        uint32_t uid;
+        int32_t signo;
+        User *user;
+        int r;
+
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        r = sd_bus_message_read(message, "ui", &uid, &signo);
+        if (r < 0)
+                return r;
+
+        if (signo <= 0 || signo >= _NSIG)
+                return sd_bus_error_setf(error, 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_error_setf(error, BUS_ERROR_NO_SUCH_USER, "No user "UID_FMT" known or logged in", uid);
+
+        r = user_kill(user, signo);
+        if (r < 0)
+                return r;
+
+        return sd_bus_reply_method_return(message, NULL);
+}
+
+static int method_terminate_session(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        Manager *m = userdata;
+        const char *name;
+        Session *session;
+        int r;
 
-        return 0;
+        assert(bus);
+        assert(message);
+        assert(m);
 
-fail:
-        if (session)
-                session_add_to_gc_queue(session);
+        r = sd_bus_message_read(message, "s", &name);
+        if (r < 0)
+                return r;
 
-        if (user)
-                user_add_to_gc_queue(user);
+        session = hashmap_get(m->sessions, name);
+        if (!session)
+                return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", name);
 
-        return r;
-}
+        r = session_stop(session, true);
+        if (r < 0)
+                return r;
 
-static int bus_manager_inhibit(
-                Manager *m,
-                DBusConnection *connection,
-                DBusMessage *message,
-                DBusError *error,
-                DBusMessage **_reply) {
+        return sd_bus_reply_method_return(message, NULL);
+}
 
-        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;
+static int method_terminate_user(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        Manager *m = userdata;
+        uint32_t uid;
+        User *user;
+        int r;
 
-        assert(m);
-        assert(connection);
+        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;
-        }
+        r = sd_bus_message_read(message, "u", &uid);
+        if (r < 0)
+                return r;
 
-        mm = inhibit_mode_from_string(mode);
-        if (mm < 0) {
-                r = -EINVAL;
-                goto fail;
-        }
+        user = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
+        if (!user)
+                return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_USER, "No user "UID_FMT" known or logged in", uid);
 
-        /* Delay is only supported for shutdown/sleep */
-        if (mm == INHIBIT_DELAY && (w & ~(INHIBIT_SHUTDOWN|INHIBIT_SLEEP))) {
-                r = -EINVAL;
-                goto fail;
-        }
+        r = user_stop(user, true);
+        if (r < 0)
+                return r;
 
-        /* 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;
-        }
+        return sd_bus_reply_method_return(message, NULL);
+}
+
+static int method_terminate_seat(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        Manager *m = userdata;
+        const char *name;
+        Seat *seat;
+        int r;
+
+        assert(bus);
+        assert(message);
+        assert(m);
 
-        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 = sd_bus_message_read(message, "s", &name);
         if (r < 0)
-                goto fail;
+                return r;
 
-        ul = dbus_bus_get_unix_user(connection, dbus_message_get_sender(message), error);
-        if (ul == (unsigned long) -1) {
-                r = -EIO;
-                goto fail;
-        }
+        seat = hashmap_get(m->seats, name);
+        if (!seat)
+                return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_SEAT, "No seat '%s' known", name);
 
-        pid = bus_get_unix_process_id(connection, dbus_message_get_sender(message), error);
-        if (pid <= 0) {
-                r = -EIO;
-                goto fail;
-        }
+        r = seat_stop_sessions(seat, true);
+        if (r < 0)
+                return r;
 
-        do {
-                free(id);
-                id = NULL;
+        return sd_bus_reply_method_return(message, NULL);
+}
 
-                if (asprintf(&id, "%lu", ++m->inhibit_counter) < 0) {
-                        r = -ENOMEM;
-                        goto fail;
-                }
-        } while (hashmap_get(m->inhibitors, id));
+static int method_set_user_linger(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        _cleanup_free_ char *cc = NULL;
+        Manager *m = userdata;
+        int b, r;
+        struct passwd *pw;
+        const char *path;
+        uint32_t uid;
+        int interactive;
 
-        r = manager_add_inhibitor(m, id, &i);
-        free(id);
+        assert(bus);
+        assert(message);
+        assert(m);
 
+        r = sd_bus_message_read(message, "ubb", &uid, &b, &interactive);
         if (r < 0)
-                goto fail;
+                return r;
 
-        i->what = w;
-        i->mode = mm;
-        i->pid = pid;
-        i->uid = (uid_t) ul;
-        i->why = strdup(why);
-        i->who = strdup(who);
+        errno = 0;
+        pw = getpwuid(uid);
+        if (!pw)
+                return errno ? -errno : -ENOENT;
+
+        r = bus_verify_polkit_async(
+                        message,
+                        CAP_SYS_ADMIN,
+                        "org.freedesktop.login1.set-user-linger",
+                        interactive,
+                        &m->polkit_registry,
+                        error);
+        if (r < 0)
+                return r;
+        if (r == 0)
+                return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
 
-        if (!i->why || !i->who) {
-                r = -ENOMEM;
-                goto fail;
-        }
+        mkdir_p_label("/var/lib/systemd", 0755);
 
-        fifo_fd = inhibitor_create_fifo(i);
-        if (fifo_fd < 0) {
-                r = fifo_fd;
-                goto fail;
-        }
+        r = mkdir_safe_label("/var/lib/systemd/linger", 0755, 0, 0);
+        if (r < 0)
+                return r;
 
-        reply = dbus_message_new_method_return(message);
-        if (!reply) {
-                r = -ENOMEM;
-                goto fail;
-        }
+        cc = cescape(pw->pw_name);
+        if (!cc)
+                return -ENOMEM;
 
-        if (!dbus_message_append_args(
-                            reply,
-                            DBUS_TYPE_UNIX_FD, &fifo_fd,
-                            DBUS_TYPE_INVALID)) {
-                r = -ENOMEM;
-                goto fail;
-        }
+        path = strappenda("/var/lib/systemd/linger/", cc);
+        if (b) {
+                User *u;
 
-        close_nointr_nofail(fifo_fd);
-        *_reply = reply;
-        reply = NULL;
+                r = touch(path);
+                if (r < 0)
+                        return r;
 
-        inhibitor_start(i);
+                if (manager_add_user_by_uid(m, uid, &u) >= 0)
+                        user_start(u);
 
-        return 0;
+        } else {
+                User *u;
 
-fail:
-        if (i)
-                inhibitor_free(i);
+                r = unlink(path);
+                if (r < 0 && errno != ENOENT)
+                        return -errno;
 
-        if (fifo_fd >= 0)
-                close_nointr_nofail(fifo_fd);
+                u = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
+                if (u)
+                        user_add_to_gc_queue(u);
+        }
 
-        return r;
+        return sd_bus_reply_method_return(message, NULL);
 }
 
 static int trigger_device(Manager *m, struct udev_device *d) {
-        struct udev_enumerate *e;
+        _cleanup_udev_enumerate_unref_ struct udev_enumerate *e = NULL;
         struct udev_list_entry *first, *item;
         int r;
 
         assert(m);
 
         e = udev_enumerate_new(m->udev);
-        if (!e) {
-                r = -ENOMEM;
-                goto finish;
-        }
+        if (!e)
+                return -ENOMEM;
 
         if (d) {
-                if (udev_enumerate_add_match_parent(e, d) < 0) {
-                        r = -EIO;
-                        goto finish;
-                }
+                r = udev_enumerate_add_match_parent(e, d);
+                if (r < 0)
+                        return r;
         }
 
-        if (udev_enumerate_scan_devices(e) < 0) {
-                r = -EIO;
-                goto finish;
-        }
+        r = udev_enumerate_scan_devices(e);
+        if (r < 0)
+                return r;
 
         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);
 
                 t = strappend(p, "/uevent");
-                if (!t) {
-                        r = -ENOMEM;
-                        goto finish;
-                }
+                if (!t)
+                        return -ENOMEM;
 
                 write_string_file(t, "change");
-                free(t);
         }
 
-        r = 0;
-
-finish:
-        if (e)
-                udev_enumerate_unref(e);
-
-        return r;
+        return 0;
 }
 
 static int attach_device(Manager *m, const char *seat, const char *sysfs) {
-        struct udev_device *d;
+        _cleanup_udev_device_unref_ struct udev_device *d = NULL;
         _cleanup_free_ char *rule = NULL, *file = NULL;
         const char *id_for_seat;
         int r;
@@ -934,40 +1129,26 @@ static int attach_device(Manager *m, const char *seat, const char *sysfs) {
         if (!d)
                 return -ENODEV;
 
-        if (!udev_device_has_tag(d, "seat")) {
-                r = -ENODEV;
-                goto finish;
-        }
+        if (!udev_device_has_tag(d, "seat"))
+                return -ENODEV;
 
         id_for_seat = udev_device_get_property_value(d, "ID_FOR_SEAT");
-        if (!id_for_seat) {
-                r = -ENODEV;
-                goto finish;
-        }
+        if (!id_for_seat)
+                return -ENODEV;
 
-        if (asprintf(&file, "/etc/udev/rules.d/72-seat-%s.rules", id_for_seat) < 0) {
-                r = -ENOMEM;
-                goto finish;
-        }
+        if (asprintf(&file, "/etc/udev/rules.d/72-seat-%s.rules", id_for_seat) < 0)
+                return -ENOMEM;
 
-        if (asprintf(&rule, "TAG==\"seat\", ENV{ID_FOR_SEAT}==\"%s\", ENV{ID_SEAT}=\"%s\"", id_for_seat, seat) < 0) {
-                r = -ENOMEM;
-                goto finish;
-        }
+        if (asprintf(&rule, "TAG==\"seat\", ENV{ID_FOR_SEAT}==\"%s\", ENV{ID_SEAT}=\"%s\"", id_for_seat, seat) < 0)
+                return -ENOMEM;
 
         mkdir_p_label("/etc/udev/rules.d", 0755);
-        label_init("/etc");
+        mac_selinux_init("/etc");
         r = write_string_file_atomic_label(file, rule);
         if (r < 0)
-                goto finish;
-
-        r = trigger_device(m, d);
-
-finish:
-        if (d)
-                udev_device_unref(d);
+                return r;
 
-        return r;
+        return trigger_device(m, d);
 }
 
 static int flush_devices(Manager *m) {
@@ -978,7 +1159,7 @@ static int flush_devices(Manager *m) {
         d = opendir("/etc/udev/rules.d");
         if (!d) {
                 if (errno != ENOENT)
-                        log_warning("Failed to open /etc/udev/rules.d: %m");
+                        log_warning_errno(errno, "Failed to open /etc/udev/rules.d: %m");
         } else {
                 struct dirent *de;
 
@@ -994,13 +1175,82 @@ static int flush_devices(Manager *m) {
                                 continue;
 
                         if (unlinkat(dirfd(d), de->d_name, 0) < 0)
-                                log_warning("Failed to unlink %s: %m", de->d_name);
+                                log_warning_errno(errno, "Failed to unlink %s: %m", de->d_name);
                 }
         }
 
         return trigger_device(m, NULL);
 }
 
+static int method_attach_device(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        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 r;
+
+        if (!path_startswith(sysfs, "/sys"))
+                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not in /sys", sysfs);
+
+        if (!seat_name_is_valid(seat))
+                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Seat %s is not valid", seat);
+
+        r = bus_verify_polkit_async(
+                        message,
+                        CAP_SYS_ADMIN,
+                        "org.freedesktop.login1.attach-device",
+                        interactive,
+                        &m->polkit_registry,
+                        error);
+        if (r < 0)
+                return r;
+        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 r;
+
+        return sd_bus_reply_method_return(message, NULL);
+}
+
+static int method_flush_devices(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        Manager *m = userdata;
+        int interactive, r;
+
+        assert(bus);
+        assert(message);
+        assert(m);
+
+        r = sd_bus_message_read(message, "b", &interactive);
+        if (r < 0)
+                return r;
+
+        r = bus_verify_polkit_async(
+                        message,
+                        CAP_SYS_ADMIN,
+                        "org.freedesktop.login1.flush-devices",
+                        interactive,
+                        &m->polkit_registry,
+                        error);
+        if (r < 0)
+                return r;
+        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 r;
+
+        return sd_bus_reply_method_return(message, NULL);
+}
+
 static int have_multiple_sessions(
                 Manager *m,
                 uid_t uid) {
@@ -1050,231 +1300,151 @@ static int bus_manager_log_shutdown(
                 q = NULL;
         }
 
-        return log_struct(LOG_NOTICE, MESSAGE_ID(SD_MESSAGE_SHUTDOWN),
+        return log_struct(LOG_NOTICE,
+                          LOG_MESSAGE_ID(SD_MESSAGE_SHUTDOWN),
                           p,
-                          q, NULL);
+                          q,
+                          NULL);
 }
 
-static int execute_shutdown_or_sleep(
-                Manager *m,
-                InhibitWhat w,
-                const char *unit_name,
-                DBusError *error) {
-
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
-        const char *mode = "replace-irreversibly", *p;
-        int r;
-        char *c;
+static int lid_switch_ignore_handler(sd_event_source *e, uint64_t usec, void *userdata) {
+        Manager *m = userdata;
 
+        assert(e);
         assert(m);
-        assert(w >= 0);
-        assert(w < _INHIBIT_WHAT_MAX);
-        assert(unit_name);
 
-        bus_manager_log_shutdown(m, w, unit_name);
+        m->lid_switch_ignore_event_source = sd_event_source_unref(m->lid_switch_ignore_event_source);
+        return 0;
+}
 
-        r = bus_method_call_with_reply(
-                        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);
-        if (r < 0)
-                return r;
+int manager_set_lid_switch_ignore(Manager *m, usec_t until) {
+        int r;
 
-        if (!dbus_message_get_args(
-                            reply,
-                            error,
-                            DBUS_TYPE_OBJECT_PATH, &p,
-                            DBUS_TYPE_INVALID))
-                return -EINVAL;
+        assert(m);
 
-        c = strdup(p);
-        if (!c)
-                return -ENOMEM;
+        if (until <= now(CLOCK_MONOTONIC))
+                return 0;
 
-        m->action_unit = unit_name;
-        free(m->action_job);
-        m->action_job = c;
-        m->action_what = w;
+        /* We want to ignore the lid switch for a while after each
+         * suspend, and after boot-up. Hence let's install a timer for
+         * this. As long as the event source exists we ignore the lid
+         * switch. */
 
-        return 0;
-}
+        if (m->lid_switch_ignore_event_source) {
+                usec_t u;
 
-static int delay_shutdown_or_sleep(
-                Manager *m,
-                InhibitWhat w,
-                const char *unit_name) {
+                r = sd_event_source_get_time(m->lid_switch_ignore_event_source, &u);
+                if (r < 0)
+                        return r;
 
-        assert(m);
-        assert(w >= 0);
-        assert(w < _INHIBIT_WHAT_MAX);
-        assert(unit_name);
+                if (until <= u)
+                        return 0;
 
-        m->action_timestamp = now(CLOCK_MONOTONIC);
-        m->action_unit = unit_name;
-        m->action_what = w;
+                r = sd_event_source_set_time(m->lid_switch_ignore_event_source, until);
+        } else
+                r = sd_event_add_time(
+                                m->event,
+                                &m->lid_switch_ignore_event_source,
+                                CLOCK_MONOTONIC,
+                                until, 0,
+                                lid_switch_ignore_handler, m);
 
-        return 0;
+        return r;
 }
 
-static int bus_manager_can_shutdown_or_sleep(
+static int execute_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_type,
-                const char *sleep_disk_type,
-                DBusError *error,
-                DBusMessage **_reply) {
+                const char *unit_name,
+                sd_bus_error *error) {
 
-        bool multiple_sessions, challenge, blocked, b;
-        const char *result = NULL;
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        const char *p;
+        char *c;
         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_type) {
-                r = can_sleep(sleep_type);
-                if (r < 0)
-                        return r;
 
-                if (r == 0) {
-                        result = "na";
-                        goto finish;
-                }
-        }
-
-        if (sleep_disk_type) {
-                r = can_sleep_disk(sleep_disk_type);
-                if (r < 0)
-                        return r;
-
-                if (r == 0) {
-                        result = "na";
-                        goto finish;
-                }
-        }
+        assert(m);
+        assert(w >= 0);
+        assert(w < _INHIBIT_WHAT_MAX);
+        assert(unit_name);
 
-        ul = dbus_bus_get_unix_user(connection, dbus_message_get_sender(message), error);
-        if (ul == (unsigned long) -1)
-                return -EIO;
+        bus_manager_log_shutdown(m, w, unit_name);
 
-        r = have_multiple_sessions(m, (uid_t) ul);
+        r = sd_bus_call_method(
+                        m->bus,
+                        "org.freedesktop.systemd1",
+                        "/org/freedesktop/systemd1",
+                        "org.freedesktop.systemd1.Manager",
+                        "StartUnit",
+                        error,
+                        &reply,
+                        "ss", unit_name, "replace-irreversibly");
         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";
-        }
+        r = sd_bus_message_read(reply, "o", &p);
+        if (r < 0)
+                return r;
 
-        if (blocked) {
-                r = verify_polkit(connection, message, action_ignore_inhibit, false, &challenge, error);
-                if (r < 0)
-                        return r;
+        c = strdup(p);
+        if (!c)
+                return -ENOMEM;
 
-                if (r > 0 && !result)
-                        result = "yes";
-                else if (challenge && (!result || streq(result, "yes")))
-                        result = "challenge";
-                else
-                        result = "no";
-        }
+        m->action_unit = unit_name;
+        free(m->action_job);
+        m->action_job = c;
+        m->action_what = w;
 
-        if (!multiple_sessions && !blocked) {
-                /* If neither inhibit nor multiple sessions
-                 * apply then just check the normal policy */
+        /* Make sure the lid switch is ignored for a while */
+        manager_set_lid_switch_ignore(m, now(CLOCK_MONOTONIC) + IGNORE_LID_SWITCH_SUSPEND_USEC);
 
-                r = verify_polkit(connection, message, action, false, &challenge, error);
-                if (r < 0)
-                        return r;
+        return 0;
+}
 
-                if (r > 0)
-                        result = "yes";
-                else if (challenge)
-                        result = "challenge";
-                else
-                        result = "no";
-        }
+static int delay_shutdown_or_sleep(
+                Manager *m,
+                InhibitWhat w,
+                const char *unit_name) {
 
-finish:
-        reply = dbus_message_new_method_return(message);
-        if (!reply)
-                return -ENOMEM;
+        assert(m);
+        assert(w >= 0);
+        assert(w < _INHIBIT_WHAT_MAX);
+        assert(unit_name);
 
-        b = dbus_message_append_args(
-                        reply,
-                        DBUS_TYPE_STRING, &result,
-                        DBUS_TYPE_INVALID);
-        if (!b)
-                return -ENOMEM;
+        m->action_timestamp = now(CLOCK_MONOTONIC);
+        m->action_unit = unit_name;
+        m->action_what = w;
 
-        *_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;
@@ -1290,7 +1460,7 @@ int bus_manager_shutdown_or_sleep_now_or_later(
 
         delayed =
                 m->inhibit_delay_max > 0 &&
-                manager_is_inhibited(m, w, INHIBIT_DELAY, NULL, false, false, 0);
+                manager_is_inhibited(m, w, INHIBIT_DELAY, NULL, false, false, 0, NULL);
 
         if (delayed)
                 /* Shutdown is delayed, keep in mind what we
@@ -1304,28 +1474,24 @@ 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_type,
-                const char *sleep_disk_type,
-                DBusError *error,
-                DBusMessage **_reply) {
+                const char *sleep_verb,
+                sd_bus_message_handler_t method,
+                sd_bus_error *error) {
 
-        dbus_bool_t interactive;
+        _cleanup_bus_creds_unref_ sd_bus_creds *creds = 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);
@@ -1333,1136 +1499,1059 @@ 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 r;
 
         /* 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_error_setf(error, BUS_ERROR_OPERATION_IN_PROGRESS, "There's already a shutdown or sleep operation in progress");
 
-        if (sleep_type) {
-                r = can_sleep(sleep_type);
+        if (sleep_verb) {
+                r = can_sleep(sleep_verb);
                 if (r < 0)
                         return r;
 
                 if (r == 0)
-                        return -ENOTSUP;
+                        return sd_bus_error_setf(error, BUS_ERROR_SLEEP_VERB_NOT_SUPPORTED, "Sleep verb not supported");
         }
 
-        if (sleep_disk_type) {
-                r = can_sleep_disk(sleep_disk_type);
-                if (r < 0)
-                        return r;
-
-                if (r == 0)
-                        return -ENOTSUP;
-        }
+        r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_UID, &creds);
+        if (r < 0)
+                return r;
 
-        ul = dbus_bus_get_unix_user(connection, dbus_message_get_sender(message), error);
-        if (ul == (unsigned long) -1)
-                return -EIO;
+        r = sd_bus_creds_get_uid(creds, &uid);
+        if (r < 0)
+                return r;
 
-        r = have_multiple_sessions(m, (uid_t) ul);
+        r = have_multiple_sessions(m, uid);
         if (r < 0)
                 return r;
 
         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, NULL);
 
         if (multiple_sessions) {
-                r = verify_polkit(connection, message, action_multiple_sessions, interactive, NULL, error);
+                r = bus_verify_polkit_async(message, CAP_SYS_BOOT, action_multiple_sessions, interactive, &m->polkit_registry, error);
                 if (r < 0)
                         return r;
+                if (r == 0)
+                        return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
         }
 
         if (blocked) {
-                r = verify_polkit(connection, message, action_ignore_inhibit, interactive, NULL, error);
+                r = bus_verify_polkit_async(message, CAP_SYS_BOOT, action_ignore_inhibit, interactive, &m->polkit_registry, error);
                 if (r < 0)
                         return r;
+                if (r == 0)
+                        return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
         }
 
         if (!multiple_sessions && !blocked) {
-                r = verify_polkit(connection, message, action, interactive, NULL, error);
+                r = bus_verify_polkit_async(message, CAP_SYS_BOOT, action, interactive, &m->polkit_registry, error);
                 if (r < 0)
                         return r;
+                if (r == 0)
+                        return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
         }
 
         r = bus_manager_shutdown_or_sleep_now_or_later(m, unit_name, w, error);
         if (r < 0)
                 return r;
 
-        reply = dbus_message_new_method_return(message);
-        if (!reply)
-                return -ENOMEM;
+        return sd_bus_reply_method_return(message, NULL);
+}
 
-        *_reply = reply;
-        return 0;
+static int method_poweroff(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        Manager *m = userdata;
+
+        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,
+                        error);
 }
 
-static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_manager_append_handle_action, handle_action, HandleAction);
-
-static const BusProperty bus_login_manager_properties[] = {
-        { "ControlGroupHierarchy",  bus_property_append_string,         "s",  offsetof(Manager, cgroup_path),        true },
-        { "Controllers",            bus_property_append_strv,           "as", offsetof(Manager, controllers),        true },
-        { "ResetControllers",       bus_property_append_strv,           "as", offsetof(Manager, reset_controllers),  true },
-        { "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 int method_reboot(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        Manager *m = userdata;
+
+        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,
+                        error);
+}
 
-static DBusHandlerResult manager_message_handler(
-                DBusConnection *connection,
-                DBusMessage *message,
-                void *userdata) {
+static int method_suspend(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        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,
+                        error);
+}
+
+static int method_hibernate(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        Manager *m = userdata;
+
+        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,
+                        error);
+}
 
+static int method_hybrid_sleep(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
         Manager *m = userdata;
 
-        DBusError error;
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+        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,
+                        error);
+}
+
+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,
+                sd_bus_error *error) {
+
+        _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
+        bool multiple_sessions, challenge, blocked;
+        const char *result = NULL;
+        uid_t uid;
         int r;
 
-        assert(connection);
-        assert(message);
         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 r;
+                if (r == 0)
+                        return sd_bus_reply_method_return(message, "s", "na");
+        }
 
-        dbus_error_init(&error);
+        r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_UID, &creds);
+        if (r < 0)
+                return r;
 
-        if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "GetSession")) {
-                const char *name;
-                char *p;
-                Session *session;
-                bool b;
+        r = sd_bus_creds_get_uid(creds, &uid);
+        if (r < 0)
+                return r;
 
-                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 r;
 
-                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, NULL);
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+        if (multiple_sessions) {
+                r = bus_verify_polkit(message, CAP_SYS_BOOT, action_multiple_sessions, false, &challenge, error);
+                if (r < 0)
+                        return r;
 
-                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;
+                if (r > 0)
+                        result = "yes";
+                else if (challenge)
+                        result = "challenge";
+                else
+                        result = "no";
+        }
 
-                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;
+        if (blocked) {
+                r = bus_verify_polkit(message, CAP_SYS_BOOT, action_ignore_inhibit, false, &challenge, error);
+                if (r < 0)
+                        return r;
 
-                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);
+                if (r > 0 && !result)
+                        result = "yes";
+                else if (challenge && (!result || streq(result, "yes")))
+                        result = "challenge";
+                else
+                        result = "no";
+        }
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+        if (!multiple_sessions && !blocked) {
+                /* If neither inhibit nor multiple sessions
+                 * apply then just check the normal policy */
 
-                p = seat_bus_path(seat);
-                if (!p)
-                        goto oom;
+                r = bus_verify_polkit(message, CAP_SYS_BOOT, action, false, &challenge, error);
+                if (r < 0)
+                        return r;
 
-                b = dbus_message_append_args(
-                                reply,
-                                DBUS_TYPE_OBJECT_PATH, &p,
-                                DBUS_TYPE_INVALID);
-                free(p);
+                if (r > 0)
+                        result = "yes";
+                else if (challenge)
+                        result = "challenge";
+                else
+                        result = "no";
+        }
 
-                if (!b)
-                        goto oom;
+        return sd_bus_reply_method_return(message, "s", result);
+}
 
-        } 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 = "";
+static int method_can_poweroff(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        Manager *m = userdata;
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+        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,
+                        error);
+}
 
-                dbus_message_iter_init_append(reply, &iter);
+static int method_can_reboot(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        Manager *m = userdata;
 
-                if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(susso)", &sub))
-                        goto oom;
+        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,
+                        error);
+}
 
-                HASHMAP_FOREACH(session, m->sessions, i) {
-                        DBusMessageIter sub2;
-                        uint32_t uid;
+static int method_can_suspend(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        Manager *m = userdata;
 
-                        if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
-                                goto oom;
+        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",
+                        error);
+}
 
-                        uid = session->user->uid;
+static int method_can_hibernate(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        Manager *m = userdata;
 
-                        p = session_bus_path(session);
-                        if (!p)
-                                goto oom;
+        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",
+                        error);
+}
 
-                        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;
-                        }
+static int method_can_hybrid_sleep(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        Manager *m = userdata;
 
-                        free(p);
+        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",
+                        error);
+}
 
-                        if (!dbus_message_iter_close_container(&sub, &sub2))
-                                goto oom;
-                }
+static int method_inhibit(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        _cleanup_bus_creds_unref_ sd_bus_creds *creds = 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;
 
-                if (!dbus_message_iter_close_container(&iter, &sub))
-                        goto oom;
+        assert(bus);
+        assert(message);
+        assert(m);
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ListUsers")) {
-                char *p;
-                User *user;
-                Iterator i;
-                DBusMessageIter iter, sub;
+        r = sd_bus_message_read(message, "ssss", &what, &who, &why, &mode);
+        if (r < 0)
+                return r;
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+        w = inhibit_what_from_string(what);
+        if (w <= 0)
+                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid what specification %s", what);
 
-                dbus_message_iter_init_append(reply, &iter);
+        mm = inhibit_mode_from_string(mode);
+        if (mm < 0)
+                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid mode specification %s", mode);
 
-                if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(uso)", &sub))
-                        goto oom;
+        /* Delay is only supported for shutdown/sleep */
+        if (mm == INHIBIT_DELAY && (w & ~(INHIBIT_SHUTDOWN|INHIBIT_SLEEP)))
+                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Delay inhibitors only supported for shutdown and sleep");
 
-                HASHMAP_FOREACH(user, m->users, i) {
-                        DBusMessageIter sub2;
-                        uint32_t uid;
+        /* 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_error_setf(error, BUS_ERROR_OPERATION_IN_PROGRESS, "The operation inhibition has been requested for is already running");
+
+        r = bus_verify_polkit_async(message, CAP_SYS_BOOT,
+                                    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, &m->polkit_registry, error);
+        if (r < 0)
+                return r;
+        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_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
-                                goto oom;
+        r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_UID|SD_BUS_CREDS_PID, &creds);
+        if (r < 0)
+                return r;
 
-                        uid = user->uid;
+        r = sd_bus_creds_get_uid(creds, &uid);
+        if (r < 0)
+                return r;
 
-                        p = user_bus_path(user);
-                        if (!p)
-                                goto oom;
+        r = sd_bus_creds_get_pid(creds, &pid);
+        if (r < 0)
+                return r;
 
-                        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;
-                        }
+        do {
+                free(id);
+                id = NULL;
 
-                        free(p);
+                if (asprintf(&id, "%lu", ++m->inhibit_counter) < 0)
+                        return -ENOMEM;
 
-                        if (!dbus_message_iter_close_container(&sub, &sub2))
-                                goto oom;
-                }
+        } while (hashmap_get(m->inhibitors, id));
 
-                if (!dbus_message_iter_close_container(&iter, &sub))
-                        goto oom;
+        r = manager_add_inhibitor(m, id, &i);
+        if (r < 0)
+                return r;
+
+        i->what = w;
+        i->mode = mm;
+        i->pid = pid;
+        i->uid = uid;
+        i->why = strdup(why);
+        i->who = strdup(who);
+
+        if (!i->why || !i->who) {
+                r = -ENOMEM;
+                goto fail;
+        }
+
+        fifo_fd = inhibitor_create_fifo(i);
+        if (fifo_fd < 0) {
+                r = fifo_fd;
+                goto fail;
+        }
+
+        inhibitor_start(i);
+
+        return sd_bus_reply_method_return(message, "h", fifo_fd);
+
+fail:
+        if (i)
+                inhibitor_free(i);
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ListSeats")) {
-                char *p;
-                Seat *seat;
-                Iterator i;
-                DBusMessageIter iter, sub;
+        return r;
+}
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+const sd_bus_vtable manager_vtable[] = {
+        SD_BUS_VTABLE_START(0),
+
+        SD_BUS_PROPERTY("NAutoVTs", "u", NULL, offsetof(Manager, n_autovts), SD_BUS_VTABLE_PROPERTY_CONST),
+        SD_BUS_PROPERTY("KillOnlyUsers", "as", NULL, offsetof(Manager, kill_only_users), SD_BUS_VTABLE_PROPERTY_CONST),
+        SD_BUS_PROPERTY("KillExcludeUsers", "as", NULL, offsetof(Manager, kill_exclude_users), SD_BUS_VTABLE_PROPERTY_CONST),
+        SD_BUS_PROPERTY("KillUserProcesses", "b", NULL, offsetof(Manager, kill_user_processes), SD_BUS_VTABLE_PROPERTY_CONST),
+        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), SD_BUS_VTABLE_PROPERTY_CONST),
+        SD_BUS_PROPERTY("HandlePowerKey", "s", property_get_handle_action, offsetof(Manager, handle_power_key), SD_BUS_VTABLE_PROPERTY_CONST),
+        SD_BUS_PROPERTY("HandleSuspendKey", "s", property_get_handle_action, offsetof(Manager, handle_suspend_key), SD_BUS_VTABLE_PROPERTY_CONST),
+        SD_BUS_PROPERTY("HandleHibernateKey", "s", property_get_handle_action, offsetof(Manager, handle_hibernate_key), SD_BUS_VTABLE_PROPERTY_CONST),
+        SD_BUS_PROPERTY("HandleLidSwitch", "s", property_get_handle_action, offsetof(Manager, handle_lid_switch), SD_BUS_VTABLE_PROPERTY_CONST),
+        SD_BUS_PROPERTY("HandleLidSwitchDocked", "s", property_get_handle_action, offsetof(Manager, handle_lid_switch_docked), SD_BUS_VTABLE_PROPERTY_CONST),
+        SD_BUS_PROPERTY("IdleAction", "s", property_get_handle_action, offsetof(Manager, idle_action), SD_BUS_VTABLE_PROPERTY_CONST),
+        SD_BUS_PROPERTY("IdleActionUSec", "t", NULL, offsetof(Manager, idle_action_usec), SD_BUS_VTABLE_PROPERTY_CONST),
+        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, SD_BUS_VTABLE_UNPRIVILEGED),
+        SD_BUS_METHOD("GetSessionByPID", "u", "o", method_get_session_by_pid, SD_BUS_VTABLE_UNPRIVILEGED),
+        SD_BUS_METHOD("GetUser", "u", "o", method_get_user, SD_BUS_VTABLE_UNPRIVILEGED),
+        SD_BUS_METHOD("GetUserByPID", "u", "o", method_get_user_by_pid, SD_BUS_VTABLE_UNPRIVILEGED),
+        SD_BUS_METHOD("GetSeat", "s", "o", method_get_seat, SD_BUS_VTABLE_UNPRIVILEGED),
+        SD_BUS_METHOD("ListSessions", NULL, "a(susso)", method_list_sessions, SD_BUS_VTABLE_UNPRIVILEGED),
+        SD_BUS_METHOD("ListUsers", NULL, "a(uso)", method_list_users, SD_BUS_VTABLE_UNPRIVILEGED),
+        SD_BUS_METHOD("ListSeats", NULL, "a(so)", method_list_seats, SD_BUS_VTABLE_UNPRIVILEGED),
+        SD_BUS_METHOD("ListInhibitors", NULL, "a(ssssuu)", method_list_inhibitors, SD_BUS_VTABLE_UNPRIVILEGED),
+        SD_BUS_METHOD("CreateSession", "uusssssussbssa(sv)", "soshusub", method_create_session, 0),
+        SD_BUS_METHOD("ReleaseSession", "s", NULL, method_release_session, 0),
+        SD_BUS_METHOD("ActivateSession", "s", NULL, method_activate_session, SD_BUS_VTABLE_UNPRIVILEGED),
+        SD_BUS_METHOD("ActivateSessionOnSeat", "ss", NULL, method_activate_session_on_seat, SD_BUS_VTABLE_UNPRIVILEGED),
+        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, SD_BUS_VTABLE_CAPABILITY(CAP_KILL)),
+        SD_BUS_METHOD("KillUser", "ui", NULL, method_kill_user, SD_BUS_VTABLE_CAPABILITY(CAP_KILL)),
+        SD_BUS_METHOD("TerminateSession", "s", NULL, method_terminate_session, SD_BUS_VTABLE_CAPABILITY(CAP_KILL)),
+        SD_BUS_METHOD("TerminateUser", "u", NULL, method_terminate_user, SD_BUS_VTABLE_CAPABILITY(CAP_KILL)),
+        SD_BUS_METHOD("TerminateSeat", "s", NULL, method_terminate_seat, SD_BUS_VTABLE_CAPABILITY(CAP_KILL)),
+        SD_BUS_METHOD("SetUserLinger", "ubb", NULL, method_set_user_linger, SD_BUS_VTABLE_UNPRIVILEGED),
+        SD_BUS_METHOD("AttachDevice", "ssb", NULL, method_attach_device, SD_BUS_VTABLE_UNPRIVILEGED),
+        SD_BUS_METHOD("FlushDevices", "b", NULL, method_flush_devices, SD_BUS_VTABLE_UNPRIVILEGED),
+        SD_BUS_METHOD("PowerOff", "b", NULL, method_poweroff, SD_BUS_VTABLE_UNPRIVILEGED),
+        SD_BUS_METHOD("Reboot", "b", NULL, method_reboot, SD_BUS_VTABLE_UNPRIVILEGED),
+        SD_BUS_METHOD("Suspend", "b", NULL, method_suspend, SD_BUS_VTABLE_UNPRIVILEGED),
+        SD_BUS_METHOD("Hibernate", "b", NULL, method_hibernate, SD_BUS_VTABLE_UNPRIVILEGED),
+        SD_BUS_METHOD("HybridSleep", "b", NULL, method_hybrid_sleep, SD_BUS_VTABLE_UNPRIVILEGED),
+        SD_BUS_METHOD("CanPowerOff", NULL, "s", method_can_poweroff, SD_BUS_VTABLE_UNPRIVILEGED),
+        SD_BUS_METHOD("CanReboot", NULL, "s", method_can_reboot, SD_BUS_VTABLE_UNPRIVILEGED),
+        SD_BUS_METHOD("CanSuspend", NULL, "s", method_can_suspend, SD_BUS_VTABLE_UNPRIVILEGED),
+        SD_BUS_METHOD("CanHibernate", NULL, "s", method_can_hibernate, SD_BUS_VTABLE_UNPRIVILEGED),
+        SD_BUS_METHOD("CanHybridSleep", NULL, "s", method_can_hybrid_sleep, SD_BUS_VTABLE_UNPRIVILEGED),
+        SD_BUS_METHOD("Inhibit", "ssss", "h", method_inhibit, SD_BUS_VTABLE_UNPRIVILEGED),
+
+        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
+};
 
-                dbus_message_iter_init_append(reply, &iter);
+static int session_jobs_reply(Session *s, const char *unit, const char *result) {
+        int r = 0;
 
-                if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(so)", &sub))
-                        goto oom;
+        assert(s);
+        assert(unit);
 
-                HASHMAP_FOREACH(seat, m->seats, i) {
-                        DBusMessageIter sub2;
+        if (!s->started)
+                return r;
 
-                        if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
-                                goto oom;
+        if (streq(result, "done"))
+                r = session_send_create_reply(s, NULL);
+        else {
+                _cleanup_bus_error_free_ sd_bus_error e = SD_BUS_ERROR_NULL;
 
-                        p = seat_bus_path(seat);
-                        if (!p)
-                                goto oom;
+                sd_bus_error_setf(&e, BUS_ERROR_JOB_FAILED, "Start job for unit %s failed with '%s'", unit, result);
+                r = session_send_create_reply(s, &e);
+        }
 
-                        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;
-                        }
+        return r;
+}
 
-                        free(p);
+int match_job_removed(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        const char *path, *result, *unit;
+        Manager *m = userdata;
+        Session *session;
+        uint32_t id;
+        User *user;
+        int r;
 
-                        if (!dbus_message_iter_close_container(&sub, &sub2))
-                                goto oom;
-                }
+        assert(bus);
+        assert(message);
+        assert(m);
 
-                if (!dbus_message_iter_close_container(&iter, &sub))
-                        goto oom;
+        r = sd_bus_message_read(message, "uoss", &id, &path, &unit, &result);
+        if (r < 0) {
+                bus_log_parse_error(r);
+                return r;
+        }
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ListInhibitors")) {
-                Inhibitor *inhibitor;
-                Iterator i;
-                DBusMessageIter iter, sub;
+        if (m->action_job && streq(m->action_job, path)) {
+                log_info("Operation finished.");
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+                /* Tell people that they now may take a lock again */
+                send_prepare_for(m, m->action_what, false);
 
-                dbus_message_iter_init_append(reply, &iter);
+                free(m->action_job);
+                m->action_job = NULL;
+                m->action_unit = NULL;
+                m->action_what = 0;
+                return 0;
+        }
 
-                if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(ssssuu)", &sub))
-                        goto oom;
+        session = hashmap_get(m->session_units, unit);
+        if (session) {
 
-                HASHMAP_FOREACH(inhibitor, m->inhibitors, i) {
-                        DBusMessageIter sub2;
-                        dbus_uint32_t uid, pid;
-                        const char *what, *who, *why, *mode;
+                if (streq_ptr(path, session->scope_job)) {
+                        free(session->scope_job);
+                        session->scope_job = NULL;
+                }
 
-                        if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
-                                goto oom;
+                session_jobs_reply(session, unit, result);
 
-                        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;
+                session_save(session);
+                session_add_to_gc_queue(session);
+        }
 
-                        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;
+        user = hashmap_get(m->user_units, unit);
+        if (user) {
 
-                        if (!dbus_message_iter_close_container(&sub, &sub2))
-                                goto oom;
+                if (streq_ptr(path, user->service_job)) {
+                        free(user->service_job);
+                        user->service_job = NULL;
                 }
 
-                if (!dbus_message_iter_close_container(&iter, &sub))
-                        goto oom;
+                if (streq_ptr(path, user->slice_job)) {
+                        free(user->slice_job);
+                        user->slice_job = NULL;
+                }
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "Inhibit")) {
+                LIST_FOREACH(sessions_by_user, session, user->sessions) {
+                        session_jobs_reply(session, unit, result);
+                }
 
-                r = bus_manager_inhibit(m, connection, message, &error, &reply);
+                user_save(user);
+                user_add_to_gc_queue(user);
+        }
 
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, &error, r);
+        return 0;
+}
 
+int match_unit_removed(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        const char *path, *unit;
+        Manager *m = userdata;
+        Session *session;
+        User *user;
+        int r;
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "CreateSession")) {
+        assert(bus);
+        assert(message);
+        assert(m);
 
-                r = bus_manager_create_session(m, message, &reply);
+        r = sd_bus_message_read(message, "so", &unit, &path);
+        if (r < 0) {
+                bus_log_parse_error(r);
+                return 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 */
+        session = hashmap_get(m->session_units, unit);
+        if (session)
+                session_add_to_gc_queue(session);
 
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
-
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ReleaseSession")) {
-                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);
-
-                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);
-
-                session = hashmap_get(m->sessions, name);
-                if (!session)
-                        return bus_send_error_reply(connection, message, &error, -ENOENT);
-
-                r = session_activate(session);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
+        user = hashmap_get(m->user_units, unit);
+        if (user)
+                user_add_to_gc_queue(user);
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+        return 0;
+}
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ActivateSessionOnSeat")) {
-                const char *session_name, *seat_name;
-                Session *session;
-                Seat *seat;
+int match_properties_changed(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        _cleanup_free_ char *unit = NULL;
+        Manager *m = userdata;
+        const char *path;
+        Session *session;
+        User *user;
+        int r;
 
-                /* Same as ActivateSession() but refuses to work if
-                 * the seat doesn't match */
+        assert(bus);
+        assert(message);
+        assert(m);
 
-                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);
+        path = sd_bus_message_get_path(message);
+        if (!path)
+                return 0;
 
-                session = hashmap_get(m->sessions, session_name);
-                if (!session)
-                        return bus_send_error_reply(connection, message, &error, -ENOENT);
+        r = unit_name_from_dbus_path(path, &unit);
+        if (r < 0)
+                /* quietly ignore non-units paths */
+                return r == -EINVAL ? 0 : r;
 
-                seat = hashmap_get(m->seats, seat_name);
-                if (!seat)
-                        return bus_send_error_reply(connection, message, &error, -ENOENT);
+        session = hashmap_get(m->session_units, unit);
+        if (session)
+                session_add_to_gc_queue(session);
 
-                if (session->seat != seat)
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
+        user = hashmap_get(m->user_units, unit);
+        if (user)
+                user_add_to_gc_queue(user);
 
-                r = session_activate(session);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
+        return 0;
+}
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+int match_reloading(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        Manager *m = userdata;
+        Session *session;
+        Iterator i;
+        int b, r;
 
-        } 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;
+        assert(bus);
 
-                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, "b", &b);
+        if (r < 0) {
+                bus_log_parse_error(r);
+                return r;
+        }
 
-                session = hashmap_get(m->sessions, name);
-                if (!session)
-                        return bus_send_error_reply(connection, message, NULL, -ENOENT);
+        if (b)
+                return 0;
 
-                if (session_send_lock(session, streq(dbus_message_get_member(message), "LockSession")) < 0)
-                        goto oom;
+        /* systemd finished reloading, let's recheck all our sessions */
+        log_debug("System manager has been reloaded, rechecking sessions...");
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+        HASHMAP_FOREACH(session, m->sessions, i)
+                session_add_to_gc_queue(session);
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "LockSessions") ||
-                   dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "UnlockSessions")) {
+        return 0;
+}
 
-                r = session_send_lock_all(m, streq(dbus_message_get_member(message), "LockSessions"));
-                if (r < 0)
-                        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", "KillSession")) {
-                const char *swho;
-                int32_t signo;
-                KillWho who;
-                const char *name;
-                Session *session;
-
-                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);
-                }
+int match_name_owner_changed(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        const char *name, *old, *new;
+        Manager *m = userdata;
+        Session *session;
+        Iterator i;
+        int r;
 
-                if (signo <= 0 || signo >= _NSIG)
-                        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);
+        char *key;
 
-                r = session_kill(session, who, signo);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
+        r = sd_bus_message_read(message, "sss", &name, &old, &new);
+        if (r < 0) {
+                bus_log_parse_error(r);
+                return r;
+        }
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+        if (isempty(old) || !isempty(new))
+                return 0;
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "KillUser")) {
-                uint32_t uid;
-                User *user;
-                int32_t signo;
+        key = set_remove(m->busnames, (char*) old);
+        if (!key)
+                return 0;
 
-                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);
+        /* Drop all controllers owned by this name */
 
-                if (signo <= 0 || signo >= _NSIG)
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
+        free(key);
 
-                user = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
-                if (!user)
-                        return bus_send_error_reply(connection, message, &error, -ENOENT);
+        HASHMAP_FOREACH(session, m->sessions, i)
+                if (session_is_controller(session, old))
+                        session_drop_controller(session);
 
-                r = user_kill(user, signo);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
+        return 0;
+}
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+int manager_send_changed(Manager *manager, const char *property, ...) {
+        char **l;
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "TerminateSession")) {
-                const char *name;
-                Session *session;
+        assert(manager);
 
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_STRING, &name,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
+        l = strv_from_stdarg_alloca(property);
 
-                session = hashmap_get(m->sessions, name);
-                if (!session)
-                        return bus_send_error_reply(connection, message, &error, -ENOENT);
+        return sd_bus_emit_properties_changed_strv(
+                        manager->bus,
+                        "/org/freedesktop/login1",
+                        "org.freedesktop.login1.Manager",
+                        l);
+}
 
-                r = session_stop(session);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
+int manager_dispatch_delayed(Manager *manager) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+        Inhibitor *offending = NULL;
+        int r;
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+        assert(manager);
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "TerminateUser")) {
-                uint32_t uid;
-                User *user;
+        if (manager->action_what == 0 || manager->action_job)
+                return 0;
 
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_UINT32, &uid,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
+        /* Continue delay? */
+        if (manager_is_inhibited(manager, manager->action_what, INHIBIT_DELAY, NULL, false, false, 0, &offending)) {
+                _cleanup_free_ char *comm = NULL, *u = NULL;
 
-                user = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
-                if (!user)
-                        return bus_send_error_reply(connection, message, &error, -ENOENT);
+                get_process_comm(offending->pid, &comm);
+                u = uid_to_name(offending->uid);
 
-                r = user_stop(user);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, r);
+                if (manager->action_timestamp + manager->inhibit_delay_max > now(CLOCK_MONOTONIC))
+                        return 0;
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+                log_info("Delay lock is active (UID "UID_FMT"/%s, PID "PID_FMT"/%s) but inhibitor timeout is reached.",
+                         offending->uid, strna(u),
+                         offending->pid, strna(comm));
+        }
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "TerminateSeat")) {
-                const char *name;
-                Seat *seat;
+        /* Actually do the operation */
+        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_message(&error, r));
 
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_STRING, &name,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
+                manager->action_unit = NULL;
+                manager->action_what = 0;
+                return r;
+        }
 
-                seat = hashmap_get(m->seats, name);
-                if (!seat)
-                        return bus_send_error_reply(connection, message, &error, -ENOENT);
+        return 1;
+}
 
-                r = seat_stop_sessions(seat);
-                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", "SetUserLinger")) {
-                uint32_t uid;
-                struct passwd *pw;
-                dbus_bool_t b, interactive;
-                char *path;
-
-                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);
+int manager_start_scope(
+                Manager *manager,
+                const char *scope,
+                pid_t pid,
+                const char *slice,
+                const char *description,
+                const char *after, const char *after2,
+                sd_bus_error *error,
+                char **job) {
+
+        _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *reply = NULL;
+        int r;
 
-                mkdir_p_label("/var/lib/systemd", 0755);
+        assert(manager);
+        assert(scope);
+        assert(pid > 1);
 
-                r = mkdir_safe_label("/var/lib/systemd/linger", 0755, 0, 0);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, &error, r);
+        r = sd_bus_message_new_method_call(
+                        manager->bus,
+                        &m,
+                        "org.freedesktop.systemd1",
+                        "/org/freedesktop/systemd1",
+                        "org.freedesktop.systemd1.Manager",
+                        "StartTransientUnit");
+        if (r < 0)
+                return r;
 
-                path = strappend("/var/lib/systemd/linger/", pw->pw_name);
-                if (!path)
-                        goto oom;
+        r = sd_bus_message_append(m, "ss", strempty(scope), "fail");
+        if (r < 0)
+                return r;
 
-                if (b) {
-                        User *u;
+        r = sd_bus_message_open_container(m, 'a', "(sv)");
+        if (r < 0)
+                return r;
 
-                        r = touch(path);
-                        free(path);
+        if (!isempty(slice)) {
+                r = sd_bus_message_append(m, "(sv)", "Slice", "s", slice);
+                if (r < 0)
+                        return r;
+        }
 
-                        if (r < 0)
-                                return bus_send_error_reply(connection, message, &error, r);
+        if (!isempty(description)) {
+                r = sd_bus_message_append(m, "(sv)", "Description", "s", description);
+                if (r < 0)
+                        return r;
+        }
 
-                        if (manager_add_user_by_uid(m, uid, &u) >= 0)
-                                user_start(u);
+        if (!isempty(after)) {
+                r = sd_bus_message_append(m, "(sv)", "After", "as", 1, after);
+                if (r < 0)
+                        return r;
+        }
 
-                } else {
-                        User *u;
+        if (!isempty(after2)) {
+                r = sd_bus_message_append(m, "(sv)", "After", "as", 1, after2);
+                if (r < 0)
+                        return r;
+        }
 
-                        r = unlink(path);
-                        free(path);
+        /* cgroup empty notification is not available in containers
+         * currently. To make this less problematic, let's shorten the
+         * stop timeout for sessions, so that we don't wait
+         * forever. */
 
-                        if (r < 0 && errno != ENOENT)
-                                return bus_send_error_reply(connection, message, &error, -errno);
+        /* Make sure that the session shells are terminated with
+         * SIGHUP since bash and friends tend to ignore SIGTERM */
+        r = sd_bus_message_append(m, "(sv)", "SendSIGHUP", "b", true);
+        if (r < 0)
+                return r;
 
-                        u = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
-                        if (u)
-                                user_add_to_gc_queue(u);
-                }
+        r = sd_bus_message_append(m, "(sv)", "PIDs", "au", 1, pid);
+        if (r < 0)
+                return r;
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+        r = sd_bus_message_close_container(m);
+        if (r < 0)
+                return r;
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "AttachDevice")) {
-                const char *sysfs, *seat;
-                dbus_bool_t interactive;
+        r = sd_bus_message_append(m, "a(sa(sv))", 0);
+        if (r < 0)
+                return r;
 
-                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);
+        r = sd_bus_call(manager->bus, m, 0, error, &reply);
+        if (r < 0)
+                return r;
 
-                if (!path_startswith(sysfs, "/sys") || !seat_name_is_valid(seat))
-                        return bus_send_error_reply(connection, message, NULL, -EINVAL);
+        if (job) {
+                const char *j;
+                char *copy;
 
-                r = verify_polkit(connection, message, "org.freedesktop.login1.attach-device", interactive, NULL, &error);
+                r = sd_bus_message_read(reply, "o", &j);
                 if (r < 0)
-                        return bus_send_error_reply(connection, message, &error, r);
+                        return r;
 
-                r = attach_device(m, seat, sysfs);
-                if (r < 0)
-                        return bus_send_error_reply(connection, message, NULL, -EINVAL);
+                copy = strdup(j);
+                if (!copy)
+                        return -ENOMEM;
 
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        goto oom;
+                *job = copy;
+        }
 
+        return 1;
+}
 
-        } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "FlushDevices")) {
-                dbus_bool_t interactive;
+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;
 
-                if (!dbus_message_get_args(
-                                    message,
-                                    &error,
-                                    DBUS_TYPE_BOOLEAN, &interactive,
-                                    DBUS_TYPE_INVALID))
-                        return bus_send_error_reply(connection, message, &error, -EINVAL);
+        assert(manager);
+        assert(unit);
 
-                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 = sd_bus_call_method(
+                        manager->bus,
+                        "org.freedesktop.systemd1",
+                        "/org/freedesktop/systemd1",
+                        "org.freedesktop.systemd1.Manager",
+                        "StartUnit",
+                        error,
+                        &reply,
+                        "ss", unit, "fail");
+        if (r < 0)
+                return 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, 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, 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",
-                                "mem", 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", "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",
-                                "disk", 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", "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",
-                                "disk", "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", "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, 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, 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",
-                                "mem", 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", "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",
-                                "disk", 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", "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",
-                                "disk", "suspend",
-                                &error, &reply);
+        if (job) {
+                const char *j;
+                char *copy;
+
+                r = sd_bus_message_read(reply, "o", &j);
                 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;
-
-                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);
-                        }
-                }
+                        return r;
 
-                HASHMAP_FOREACH(user, m->users, i)
-                        fprintf(f, "<node name=\"user/%llu\"/>", (unsigned long long) user->uid);
+                copy = strdup(j);
+                if (!copy)
+                        return -ENOMEM;
 
-                HASHMAP_FOREACH(session, m->sessions, i) {
-                        p = bus_path_escape(session->id);
+                *job = copy;
+        }
 
-                        if (p) {
-                                fprintf(f, "<node name=\"session/%s\"/>", p);
-                                free(p);
-                        }
-                }
+        return 1;
+}
 
-                fputs(INTROSPECTION_END, f);
+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;
 
-                if (ferror(f)) {
-                        fclose(f);
-                        free(introspection);
-                        goto oom;
-                }
+        assert(manager);
+        assert(unit);
 
-                fclose(f);
+        r = sd_bus_call_method(
+                        manager->bus,
+                        "org.freedesktop.systemd1",
+                        "/org/freedesktop/systemd1",
+                        "org.freedesktop.systemd1.Manager",
+                        "StopUnit",
+                        error,
+                        &reply,
+                        "ss", unit, "fail");
+        if (r < 0) {
+                if (sd_bus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT) ||
+                    sd_bus_error_has_name(error, BUS_ERROR_LOAD_FAILED)) {
 
-                if (!introspection)
-                        goto oom;
+                        if (job)
+                                *job = NULL;
 
-                if (!dbus_message_append_args(reply, DBUS_TYPE_STRING, &introspection, DBUS_TYPE_INVALID)) {
-                        free(introspection);
-                        goto oom;
+                        sd_bus_error_free(error);
+                        return 0;
                 }
 
-                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;
+                return r;
         }
 
-        return DBUS_HANDLER_RESULT_HANDLED;
+        if (job) {
+                const char *j;
+                char *copy;
 
-oom:
-        dbus_error_free(&error);
-
-        return DBUS_HANDLER_RESULT_NEED_MEMORY;
-}
+                r = sd_bus_message_read(reply, "o", &j);
+                if (r < 0)
+                        return r;
 
-const DBusObjectPathVTable bus_manager_vtable = {
-        .message_function = manager_message_handler
-};
+                copy = strdup(j);
+                if (!copy)
+                        return -ENOMEM;
 
-DBusHandlerResult bus_message_filter(
-                DBusConnection *connection,
-                DBusMessage *message,
-                void *userdata) {
+                *job = copy;
+        }
 
-        Manager *m = userdata;
-        DBusError error;
+        return 1;
+}
 
-        assert(m);
-        assert(connection);
-        assert(message);
+int manager_abandon_scope(Manager *manager, const char *scope, sd_bus_error *error) {
+        _cleanup_free_ char *path = NULL;
+        int r;
 
-        dbus_error_init(&error);
+        assert(manager);
+        assert(scope);
 
-        if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Agent", "Released")) {
-                const char *cgroup;
+        path = unit_dbus_path_from_name(scope);
+        if (!path)
+                return -ENOMEM;
 
-                if (!dbus_message_get_args(message, &error,
-                                           DBUS_TYPE_STRING, &cgroup,
-                                           DBUS_TYPE_INVALID))
-                        log_error("Failed to parse Released message: %s", bus_error_message(&error));
-                else
-                        manager_cgroup_notify_empty(m, cgroup);
-
-        } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "JobRemoved")) {
-                uint32_t id;
-                const char *path, *result, *unit;
-
-                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));
-
-                else 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_call_method(
+                        manager->bus,
+                        "org.freedesktop.systemd1",
+                        path,
+                        "org.freedesktop.systemd1.Scope",
+                        "Abandon",
+                        error,
+                        NULL,
+                        NULL);
+        if (r < 0) {
+                if (sd_bus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT) ||
+                    sd_bus_error_has_name(error, BUS_ERROR_LOAD_FAILED) ||
+                    sd_bus_error_has_name(error, BUS_ERROR_SCOPE_NOT_RUNNING)) {
+                        sd_bus_error_free(error);
+                        return 0;
                 }
-        }
 
-        dbus_error_free(&error);
+                return r;
+        }
 
-        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+        return 1;
 }
 
-int manager_send_changed(Manager *manager, const char *properties) {
-        _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
-
+int manager_kill_unit(Manager *manager, const char *unit, KillWho who, int signo, sd_bus_error *error) {
         assert(manager);
+        assert(unit);
 
-        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;
-
-        return 0;
+        return sd_bus_call_method(
+                        manager->bus,
+                        "org.freedesktop.systemd1",
+                        "/org/freedesktop/systemd1",
+                        "org.freedesktop.systemd1.Manager",
+                        "KillUnit",
+                        error,
+                        NULL,
+                        "ssi", unit, who == KILL_LEADER ? "main" : "all", signo);
 }
 
-int manager_dispatch_delayed(Manager *manager) {
-        DBusError error;
+int manager_unit_is_active(Manager *manager, const char *unit) {
+        _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;
+        const char *state;
         int r;
 
         assert(manager);
+        assert(unit);
 
-        if (manager->action_what == 0 || manager->action_job)
-                return 0;
+        path = unit_dbus_path_from_name(unit);
+        if (!path)
+                return -ENOMEM;
 
-        /* Continue delay? */
-        if (manager_is_inhibited(manager, manager->action_what, INHIBIT_DELAY, NULL, false, false, 0)) {
+        r = sd_bus_get_property(
+                        manager->bus,
+                        "org.freedesktop.systemd1",
+                        path,
+                        "org.freedesktop.systemd1.Unit",
+                        "ActiveState",
+                        &error,
+                        &reply,
+                        "s");
+        if (r < 0) {
+                /* 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 (manager->action_timestamp + manager->inhibit_delay_max > now(CLOCK_MONOTONIC))
-                        return 0;
+                /* 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_info("Delay lock is active but inhibitor timeout is reached.");
+                return r;
         }
 
-        /* Actually do the operation */
-        dbus_error_init(&error);
-        r = execute_shutdown_or_sleep(manager, manager->action_what, manager->action_unit, &error);
+        r = sd_bus_message_read(reply, "s", &state);
+        if (r < 0)
+                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) {
-                log_warning("Failed to send delayed message: %s", bus_error(&error, r));
-                dbus_error_free(&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 (sd_bus_error_has_name(&error, SD_BUS_ERROR_UNKNOWN_OBJECT))
+                        return false;
 
-                manager->action_unit = NULL;
-                manager->action_what = 0;
                 return r;
         }
 
-        return 1;
+        /* We don't actually care about the state really. The fact
+         * that we could read the job state is enough for us */
+
+        return true;
 }