loginctl: convert to sd-bus

NOTE: the show-* subcommands do not print some properties:
  this are those with types like (so), a(so), (uo),...
  we need to fix this, but I'm not sure how

1 files changed, 517 insertions, 849 deletions

diff --git a/src/login/loginctl.c b/src/login/loginctl.c
index dc96e4bd6..cb05907ff 100644
--- a/src/login/loginctl.c
+++ b/src/login/loginctl.c
@@ -19,7 +19,6 @@
   along with systemd; If not, see <http://www.gnu.org/licenses/>.
 ***/
 
-#include <dbus/dbus.h>
 #include <unistd.h>
 #include <errno.h>
 #include <string.h>
@@ -27,11 +26,13 @@
 #include <pwd.h>
 #include <locale.h>
 
+#include "sd-bus.h"
+#include "bus-util.h"
+#include "bus-error.h"
 #include "log.h"
 #include "util.h"
 #include "macro.h"
 #include "pager.h"
-#include "dbus-common.h"
 #include "build.h"
 #include "strv.h"
 #include "unit-name.h"
@@ -46,14 +47,9 @@ static bool arg_full = false;
 static bool arg_no_pager = false;
 static const char *arg_kill_who = NULL;
 static int arg_signal = SIGTERM;
-static enum transport {
-        TRANSPORT_NORMAL,
-        TRANSPORT_SSH,
-        TRANSPORT_POLKIT
-} arg_transport = TRANSPORT_NORMAL;
+static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
 static bool arg_ask_password = true;
 static char *arg_host = NULL;
-static char *arg_user = NULL;
 
 static void pager_open_if_enabled(void) {
 
@@ -74,245 +70,164 @@ static void polkit_agent_open_if_enabled(void) {
         polkit_agent_open();
 }
 
-static int list_sessions(DBusConnection *bus, char **args, unsigned n) {
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
-        int r;
-        DBusMessageIter iter, sub, sub2;
+static int log_parse_error(int r) {
+        log_error("Failed to parse message: %s", strerror(-r));
+        return r;
+}
+
+static int list_sessions(sd_bus *bus, char **args, unsigned n) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        const char *id, *user, *seat, *object;
         unsigned k = 0;
+        uint32_t uid;
+        int r;
 
         pager_open_if_enabled();
 
-        r = bus_method_call_with_reply (
+        r = sd_bus_call_method(
                         bus,
                         "org.freedesktop.login1",
                         "/org/freedesktop/login1",
                         "org.freedesktop.login1.Manager",
                         "ListSessions",
-                        &reply,
-                        NULL,
-                        DBUS_TYPE_INVALID);
-        if (r)
+                        &error, &reply,
+                        "");
+        if (r < 0) {
+                log_error("Failed to list sessions: %s", bus_error_message(&error, r));
                 return r;
-
-        if (!dbus_message_iter_init(reply, &iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
-            dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT)  {
-                log_error("Failed to parse reply.");
-                return -EIO;
         }
 
-        dbus_message_iter_recurse(&iter, &sub);
-
-        if (on_tty())
-                printf("%10s %10s %-16s %-16s\n", "SESSION", "UID", "USER", "SEAT");
-
-        while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
-                const char *id, *user, *seat, *object;
-                uint32_t uid;
-
-                if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
-                        log_error("Failed to parse reply.");
-                        return -EIO;
-                }
-
-                dbus_message_iter_recurse(&sub, &sub2);
+        r = sd_bus_message_enter_container(reply, 'a', "(susso)");
+        if (r < 0)
+                return log_parse_error(r);
 
-                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &id, true) < 0 ||
-                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &uid, true) < 0 ||
-                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &user, true) < 0 ||
-                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &seat, true) < 0 ||
-                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &object, false) < 0) {
-                        log_error("Failed to parse reply.");
-                        return -EIO;
-                }
+        printf("%10s %10s %-16s %-16s\n", "SESSION", "UID", "USER", "SEAT");
 
+        while ((r = sd_bus_message_read(reply, "(susso)", &id, &uid, &user, &seat, &object)) > 0) {
                 printf("%10s %10u %-16s %-16s\n", id, (unsigned) uid, user, seat);
-
                 k++;
-
-                dbus_message_iter_next(&sub);
         }
+        if (r < 0)
+                return log_parse_error(r);
 
-        if (on_tty())
-                printf("\n%u sessions listed.\n", k);
+        printf("\n%u sessions listed.\n", k);
 
         return 0;
 }
 
-static int list_users(DBusConnection *bus, char **args, unsigned n) {
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
-        int r;
-        DBusMessageIter iter, sub, sub2;
+static int list_users(sd_bus *bus, char **args, unsigned n) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        const char *user, *object;
         unsigned k = 0;
+        uint32_t uid;
+        int r;
 
         pager_open_if_enabled();
 
-        r = bus_method_call_with_reply (
+        r = sd_bus_call_method(
                         bus,
                         "org.freedesktop.login1",
                         "/org/freedesktop/login1",
                         "org.freedesktop.login1.Manager",
                         "ListUsers",
-                        &reply,
-                        NULL,
-                        DBUS_TYPE_INVALID);
-        if (r)
+                        &error, &reply,
+                        "");
+        if (r < 0) {
+                log_error("Failed to list users: %s", bus_error_message(&error, r));
                 return r;
-
-        if (!dbus_message_iter_init(reply, &iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
-            dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT)  {
-                log_error("Failed to parse reply.");
-                return -EIO;
         }
 
-        dbus_message_iter_recurse(&iter, &sub);
-
-        if (on_tty())
-                printf("%10s %-16s\n", "UID", "USER");
-
-        while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
-                const char *user, *object;
-                uint32_t uid;
-
-                if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
-                        log_error("Failed to parse reply.");
-                        return -EIO;
-                }
-
-                dbus_message_iter_recurse(&sub, &sub2);
+        r = sd_bus_message_enter_container(reply, 'a', "(uso)");
+        if (r < 0)
+                return log_parse_error(r);
 
-                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &uid, true) < 0 ||
-                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &user, true) < 0 ||
-                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &object, false) < 0) {
-                        log_error("Failed to parse reply.");
-                        return -EIO;
-                }
+        printf("%10s %-16s\n", "UID", "USER");
 
+        while ((r = sd_bus_message_read(reply, "(uso)", &uid, &user, &object)) > 0) {
                 printf("%10u %-16s\n", (unsigned) uid, user);
-
                 k++;
-
-                dbus_message_iter_next(&sub);
         }
+        if (r < 0)
+                return log_parse_error(r);
 
-        if (on_tty())
-                printf("\n%u users listed.\n", k);
+        printf("\n%u users listed.\n", k);
 
         return 0;
 }
 
-static int list_seats(DBusConnection *bus, char **args, unsigned n) {
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
-        int r;
-        DBusMessageIter iter, sub, sub2;
+static int list_seats(sd_bus *bus, char **args, unsigned n) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        const char *seat, *object;
         unsigned k = 0;
+        int r;
 
         pager_open_if_enabled();
 
-        r = bus_method_call_with_reply (
+        r = sd_bus_call_method(
                         bus,
                         "org.freedesktop.login1",
                         "/org/freedesktop/login1",
                         "org.freedesktop.login1.Manager",
                         "ListSeats",
-                        &reply,
-                        NULL,
-                        DBUS_TYPE_INVALID);
-        if (r)
+                        &error, &reply,
+                        "");
+        if (r < 0) {
+                log_error("Failed to list seats: %s", bus_error_message(&error, r));
                 return r;
-
-        if (!dbus_message_iter_init(reply, &iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
-            dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT)  {
-                log_error("Failed to parse reply.");
-                return -EIO;
         }
 
-        dbus_message_iter_recurse(&iter, &sub);
-
-        if (on_tty())
-                printf("%-16s\n", "SEAT");
-
-        while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
-                const char *seat, *object;
-
-                if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
-                        log_error("Failed to parse reply.");
-                        return -EIO;
-                }
-
-                dbus_message_iter_recurse(&sub, &sub2);
+        r = sd_bus_message_enter_container(reply, 'a', "(so)");
+        if (r < 0)
+                return log_parse_error(r);
 
-                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &seat, true) < 0 ||
-                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &object, false) < 0) {
-                        log_error("Failed to parse reply.");
-                        return -EIO;
-                }
+        printf("%-16s\n", "SEAT");
 
+        while ((r = sd_bus_message_read(reply, "(so)", &seat, &object)) > 0) {
                 printf("%-16s\n", seat);
-
                 k++;
-
-                dbus_message_iter_next(&sub);
         }
+        if (r < 0)
+                return log_parse_error(r);
 
-        if (on_tty())
-                printf("\n%u seats listed.\n", k);
+        printf("\n%u seats listed.\n", k);
 
         return 0;
 }
 
-static int show_unit_cgroup(DBusConnection *bus, const char *interface, const char *unit, pid_t leader) {
-        const char *property = "ControlGroup";
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+static int show_unit_cgroup(sd_bus *bus, const char *interface, const char *unit, pid_t leader) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
         _cleanup_free_ char *path = NULL;
-        DBusMessageIter iter, sub;
         const char *cgroup;
-        DBusError error;
         int r, output_flags;
         unsigned c;
 
         assert(bus);
         assert(unit);
 
-        if (arg_transport == TRANSPORT_SSH)
+        if (arg_transport != BUS_TRANSPORT_LOCAL)
                 return 0;
 
         path = unit_dbus_path_from_name(unit);
         if (!path)
-                return log_oom();
+                return -ENOMEM;
 
-        r = bus_method_call_with_reply(
+        r = sd_bus_get_property(
                         bus,
                         "org.freedesktop.systemd1",
                         path,
-                        "org.freedesktop.DBus.Properties",
-                        "Get",
-                        &reply,
-                        &error,
-                        DBUS_TYPE_STRING, &interface,
-                        DBUS_TYPE_STRING, &property,
-                        DBUS_TYPE_INVALID);
-        if (r < 0) {
-                log_error("Failed to query ControlGroup: %s", bus_error(&error, r));
-                dbus_error_free(&error);
+                        interface,
+                        "ControlGroup",
+                        &error, &reply, "s");
+        if (r < 0)
                 return r;
-        }
 
-        if (!dbus_message_iter_init(reply, &iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {
-                log_error("Failed to parse reply.");
-                return -EINVAL;
-        }
-
-        dbus_message_iter_recurse(&iter, &sub);
-        if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING) {
-                log_error("Failed to parse reply.");
-                return -EINVAL;
-        }
-
-        dbus_message_iter_get_basic(&sub, &cgroup);
+        r = sd_bus_message_read(reply, "s", &cgroup);
+        if (r < 0)
+                return r;
 
         if (isempty(cgroup))
                 return 0;
@@ -370,116 +285,225 @@ typedef struct SeatStatusInfo {
         char **sessions;
 } SeatStatusInfo;
 
-static void print_session_status_info(DBusConnection *bus, SessionStatusInfo *i) {
+static int prop_map_first_of_struct(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {
+        const char *contents;
+        int r;
+
+        r = sd_bus_message_peek_type(m, NULL, &contents);
+        if (r < 0)
+                return r;
+
+        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_STRUCT, contents);
+        if (r < 0)
+                return r;
+
+        if (contents[0] == 's' || contents[0] == 'o') {
+                const char *s;
+                char **p = (char **) userdata;
+
+                r = sd_bus_message_read_basic(m, contents[0], &s);
+                if (r < 0)
+                        return r;
+
+                free(*p);
+                *p = strdup(s);
+
+                if (!*p)
+                        return -ENOMEM;
+        } else {
+                r = sd_bus_message_read_basic(m, contents[0], userdata);
+                if (r < 0)
+                        return r;
+        }
+
+        r = sd_bus_message_skip(m, contents+1);
+        if (r < 0)
+                return r;
+
+        r = sd_bus_message_exit_container(m);
+        if (r < 0)
+                return r;
+
+        return 0;
+}
+
+static int prop_map_sessions_strv(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {
+        const char *name;
+        int r;
+
+        assert(bus);
+        assert(m);
+
+        r = sd_bus_message_enter_container(m, 'a', "(so)");
+        if (r < 0)
+                return r;
+
+        while ((r = sd_bus_message_read(m, "(so)", &name, NULL)) > 0) {
+                r = strv_extend(userdata, name);
+                if (r < 0)
+                        return r;
+        }
+        if (r < 0)
+                return r;
+
+        return sd_bus_message_exit_container(m);
+}
+
+static int print_session_status_info(sd_bus *bus, const char *path) {
+
+        static const struct bus_properties_map map[]  = {
+                { "Id",         "s", NULL, offsetof(SessionStatusInfo, id) },
+                { "Name",       "s", NULL, offsetof(SessionStatusInfo, name) },
+                { "TTY",        "s", NULL, offsetof(SessionStatusInfo, tty) },
+                { "Display",    "s", NULL, offsetof(SessionStatusInfo, display) },
+                { "RemoteHost", "s", NULL, offsetof(SessionStatusInfo, remote_host) },
+                { "RemoteUser", "s", NULL, offsetof(SessionStatusInfo, remote_user) },
+                { "Service",    "s", NULL, offsetof(SessionStatusInfo, service) },
+                { "Type",       "s", NULL, offsetof(SessionStatusInfo, type) },
+                { "Class",      "s", NULL, offsetof(SessionStatusInfo, class) },
+                { "Scope",      "s", NULL, offsetof(SessionStatusInfo, scope) },
+                { "State",      "s", NULL, offsetof(SessionStatusInfo, state) },
+                { "VTNr",       "u", NULL, offsetof(SessionStatusInfo, vtnr) },
+                { "Leader",     "u", NULL, offsetof(SessionStatusInfo, leader) },
+                { "Remote",     "b", NULL, offsetof(SessionStatusInfo, remote) },
+                { "Timestamp",  "t", NULL, offsetof(SessionStatusInfo, timestamp) },
+                { "User",       "(uo)", prop_map_first_of_struct, offsetof(SessionStatusInfo, uid) },
+                { "Seat",       "(so)", prop_map_first_of_struct, offsetof(SessionStatusInfo, id) },
+                {}
+        };
+
+        SessionStatusInfo i = {};
         char since1[FORMAT_TIMESTAMP_RELATIVE_MAX], *s1;
         char since2[FORMAT_TIMESTAMP_MAX], *s2;
-        assert(i);
+        int r;
+
+        r = bus_map_all_properties(bus, "org.freedesktop.login1", path, map, &i);
+        if (r < 0)
+                return r;
 
-        printf("%s - ", strna(i->id));
+        printf("%s - ", strna(i.id));
 
-        if (i->name)
-                printf("%s (%u)\n", i->name, (unsigned) i->uid);
+        if (i.name)
+                printf("%s (%u)\n", i.name, (unsigned) i.uid);
         else
-                printf("%u\n", (unsigned) i->uid);
+                printf("%u\n", (unsigned) i.uid);
 
-        s1 = format_timestamp_relative(since1, sizeof(since1), i->timestamp);
-        s2 = format_timestamp(since2, sizeof(since2), i->timestamp);
+        s1 = format_timestamp_relative(since1, sizeof(since1), i.timestamp);
+        s2 = format_timestamp(since2, sizeof(since2), i.timestamp);
 
         if (s1)
                 printf("\t   Since: %s; %s\n", s2, s1);
         else if (s2)
                 printf("\t   Since: %s\n", s2);
 
-        if (i->leader > 0) {
+        if (i.leader > 0) {
                 _cleanup_free_ char *t = NULL;
 
-                printf("\t  Leader: %u", (unsigned) i->leader);
+                printf("\t  Leader: %u", (unsigned) i.leader);
 
-                get_process_comm(i->leader, &t);
+                get_process_comm(i.leader, &t);
                 if (t)
                         printf(" (%s)", t);
 
                 printf("\n");
         }
 
-        if (i->seat) {
-                printf("\t    Seat: %s", i->seat);
+        if (i.seat) {
+                printf("\t    Seat: %s", i.seat);
 
-                if (i->vtnr > 0)
-                        printf("; vc%i", i->vtnr);
+                if (i.vtnr > 0)
+                        printf("; vc%i", i.vtnr);
 
                 printf("\n");
         }
 
-        if (i->tty)
-                printf("\t     TTY: %s\n", i->tty);
-        else if (i->display)
-                printf("\t Display: %s\n", i->display);
-
-        if (i->remote_host && i->remote_user)
-                printf("\t  Remote: %s@%s\n", i->remote_user, i->remote_host);
-        else if (i->remote_host)
-                printf("\t  Remote: %s\n", i->remote_host);
-        else if (i->remote_user)
-                printf("\t  Remote: user %s\n", i->remote_user);
-        else if (i->remote)
+        if (i.tty)
+                printf("\t     TTY: %s\n", i.tty);
+        else if (i.display)
+                printf("\t Display: %s\n", i.display);
+
+        if (i.remote_host && i.remote_user)
+                printf("\t  Remote: %s@%s\n", i.remote_user, i.remote_host);
+        else if (i.remote_host)
+                printf("\t  Remote: %s\n", i.remote_host);
+        else if (i.remote_user)
+                printf("\t  Remote: user %s\n", i.remote_user);
+        else if (i.remote)
                 printf("\t  Remote: Yes\n");
 
-        if (i->service) {
-                printf("\t Service: %s", i->service);
+        if (i.service) {
+                printf("\t Service: %s", i.service);
 
-                if (i->type)
-                        printf("; type %s", i->type);
+                if (i.type)
+                        printf("; type %s", i.type);
 
-                if (i->class)
-                        printf("; class %s", i->class);
+                if (i.class)
+                        printf("; class %s", i.class);
 
                 printf("\n");
-        } else if (i->type) {
-                printf("\t    Type: %s\n", i->type);
+        } else if (i.type) {
+                printf("\t    Type: %s\n", i.type);
 
-                if (i->class)
-                        printf("; class %s", i->class);
-        } else if (i->class)
-                printf("\t   Class: %s\n", i->class);
+                if (i.class)
+                        printf("; class %s", i.class);
+        } else if (i.class)
+                printf("\t   Class: %s\n", i.class);
 
-        if (i->state)
-                printf("\t   State: %s\n", i->state);
+        if (i.state)
+                printf("\t   State: %s\n", i.state);
 
-        if (i->scope) {
-                printf("\t    Unit: %s\n", i->scope);
-                show_unit_cgroup(bus, "org.freedesktop.systemd1.Scope", i->scope, i->leader);
+        if (i.scope) {
+                printf("\t    Unit: %s\n", i.scope);
+                show_unit_cgroup(bus, "org.freedesktop.systemd1.Scope", i.scope, i.leader);
         }
+
+        return 0;
 }
 
-static void print_user_status_info(DBusConnection *bus, UserStatusInfo *i) {
+static int print_user_status_info(sd_bus *bus, const char *path) {
+
+        static const struct bus_properties_map map[]  = {
+                { "Name",       "s",     NULL, offsetof(UserStatusInfo, name) },
+                { "Slice",      "s",     NULL, offsetof(UserStatusInfo, slice) },
+                { "State",      "s",     NULL, offsetof(UserStatusInfo, state) },
+                { "UID",        "u",     NULL, offsetof(UserStatusInfo, uid) },
+                { "Timestamp",  "t",     NULL, offsetof(UserStatusInfo, timestamp) },
+                { "Display",    "(so)",  prop_map_first_of_struct, offsetof(UserStatusInfo, display) },
+                { "Sessions",   "a(so)", prop_map_sessions_strv,   offsetof(UserStatusInfo, sessions) },
+                {}
+        };
+
         char since1[FORMAT_TIMESTAMP_RELATIVE_MAX], *s1;
         char since2[FORMAT_TIMESTAMP_MAX], *s2;
-        assert(i);
+        UserStatusInfo i = {};
+        int r;
 
-        if (i->name)
-                printf("%s (%u)\n", i->name, (unsigned) i->uid);
+        r = bus_map_all_properties(bus, "org.freedesktop.login1", path, map, &i);
+        if (r < 0)
+                goto finish;
+
+        if (i.name)
+                printf("%s (%u)\n", i.name, (unsigned) i.uid);
         else
-                printf("%u\n", (unsigned) i->uid);
+                printf("%u\n", (unsigned) i.uid);
 
-        s1 = format_timestamp_relative(since1, sizeof(since1), i->timestamp);
-        s2 = format_timestamp(since2, sizeof(since2), i->timestamp);
+        s1 = format_timestamp_relative(since1, sizeof(since1), i.timestamp);
+        s2 = format_timestamp(since2, sizeof(since2), i.timestamp);
 
         if (s1)
                 printf("\t   Since: %s; %s\n", s2, s1);
         else if (s2)
                 printf("\t   Since: %s\n", s2);
 
-        if (!isempty(i->state))
-                printf("\t   State: %s\n", i->state);
+        if (!isempty(i.state))
+                printf("\t   State: %s\n", i.state);
 
-
-        if (!strv_isempty(i->sessions)) {
+        if (!strv_isempty(i.sessions)) {
                 char **l;
                 printf("\tSessions:");
 
-                STRV_FOREACH(l, i->sessions) {
-                        if (streq_ptr(*l, i->display))
+                STRV_FOREACH(l, i.sessions) {
+                        if (streq_ptr(*l, i.display))
                                 printf(" *%s", *l);
                         else
                                 printf(" %s", *l);
@@ -488,23 +512,41 @@ static void print_user_status_info(DBusConnection *bus, UserStatusInfo *i) {
                 printf("\n");
         }
 
-        if (i->slice) {
-                printf("\t    Unit: %s\n", i->slice);
-                show_unit_cgroup(bus, "org.freedesktop.systemd1.Slice", i->slice, 0);
+        if (i.slice) {
+                printf("\t    Unit: %s\n", i.slice);
+                show_unit_cgroup(bus, "org.freedesktop.systemd1.Slice", i.slice, 0);
         }
+
+finish:
+        strv_free(i.sessions);
+
+        return 0;
 }
 
-static void print_seat_status_info(SeatStatusInfo *i) {
-        assert(i);
+static int print_seat_status_info(sd_bus *bus, const char *path) {
 
-        printf("%s\n", strna(i->id));
+        static const struct bus_properties_map map[]  = {
+                { "Id",            "s",     NULL, offsetof(SeatStatusInfo, id) },
+                { "ActiveSession", "(so)",  &prop_map_first_of_struct, offsetof(SeatStatusInfo, active_session) },
+                { "Sessions",      "a(so)", &prop_map_sessions_strv, offsetof(SeatStatusInfo, sessions) },
+                {}
+        };
 
-        if (!strv_isempty(i->sessions)) {
+        SeatStatusInfo i = {};
+        int r;
+
+        r = bus_map_all_properties(bus, "org.freedesktop.login1", path, map, &i);
+        if (r < 0)
+                goto finish;
+
+        printf("%s\n", strna(i.id));
+
+        if (!strv_isempty(i.sessions)) {
                 char **l;
                 printf("\tSessions:");
 
-                STRV_FOREACH(l, i->sessions) {
-                        if (streq_ptr(*l, i->active_session))
+                STRV_FOREACH(l, i.sessions) {
+                        if (streq_ptr(*l, i.active_session))
                                 printf(" *%s", *l);
                         else
                                 printf(" %s", *l);
@@ -513,7 +555,7 @@ static void print_seat_status_info(SeatStatusInfo *i) {
                 printf("\n");
         }
 
-        if (arg_transport != TRANSPORT_SSH) {
+        if (arg_transport == BUS_TRANSPORT_LOCAL) {
                 unsigned c;
 
                 c = columns();
@@ -524,464 +566,150 @@ static void print_seat_status_info(SeatStatusInfo *i) {
 
                 printf("\t Devices:\n");
 
-                show_sysfs(i->id, "\t\t  ", c);
+                show_sysfs(i.id, "\t\t  ", c);
         }
-}
-
-static int status_property_session(const char *name, DBusMessageIter *iter, SessionStatusInfo *i) {
-        assert(name);
-        assert(iter);
-        assert(i);
-
-        switch (dbus_message_iter_get_arg_type(iter)) {
-
-        case DBUS_TYPE_STRING: {
-                const char *s;
-
-                dbus_message_iter_get_basic(iter, &s);
-
-                if (!isempty(s)) {
-                        if (streq(name, "Id"))
-                                i->id = s;
-                        else if (streq(name, "Name"))
-                                i->name = s;
-                        else if (streq(name, "TTY"))
-                                i->tty = s;
-                        else if (streq(name, "Display"))
-                                i->display = s;
-                        else if (streq(name, "RemoteHost"))
-                                i->remote_host = s;
-                        else if (streq(name, "RemoteUser"))
-                                i->remote_user = s;
-                        else if (streq(name, "Service"))
-                                i->service = s;
-                        else if (streq(name, "Type"))
-                                i->type = s;
-                        else if (streq(name, "Class"))
-                                i->class = s;
-                        else if (streq(name, "Scope"))
-                                i->scope = s;
-                        else if (streq(name, "State"))
-                                i->state = s;
-                }
-                break;
-        }
-
-        case DBUS_TYPE_UINT32: {
-                uint32_t u;
-
-                dbus_message_iter_get_basic(iter, &u);
-
-                if (streq(name, "VTNr"))
-                        i->vtnr = (int) u;
-                else if (streq(name, "Leader"))
-                        i->leader = (pid_t) u;
-
-                break;
-        }
-
-        case DBUS_TYPE_BOOLEAN: {
-                dbus_bool_t b;
-
-                dbus_message_iter_get_basic(iter, &b);
-
-                if (streq(name, "Remote"))
-                        i->remote = b;
-
-                break;
-        }
-
-        case DBUS_TYPE_UINT64: {
-                uint64_t u;
-
-                dbus_message_iter_get_basic(iter, &u);
-
-                if (streq(name, "Timestamp"))
-                        i->timestamp = (usec_t) u;
-
-                break;
-        }
-
-        case DBUS_TYPE_STRUCT: {
-                DBusMessageIter sub;
-
-                dbus_message_iter_recurse(iter, &sub);
-
-                if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_UINT32 && streq(name, "User")) {
-                        uint32_t u;
-
-                        dbus_message_iter_get_basic(&sub, &u);
-                        i->uid = (uid_t) u;
-
-                } else if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING && streq(name, "Seat")) {
-                        const char *s;
-
-                        dbus_message_iter_get_basic(&sub, &s);
-
-                        if (!isempty(s))
-                                i->seat = s;
-                }
-
-                break;
-        }
-        }
-
-        return 0;
-}
-
-static int status_property_user(const char *name, DBusMessageIter *iter, UserStatusInfo *i) {
-        assert(name);
-        assert(iter);
-        assert(i);
-
-        switch (dbus_message_iter_get_arg_type(iter)) {
-
-        case DBUS_TYPE_STRING: {
-                const char *s;
-
-                dbus_message_iter_get_basic(iter, &s);
-
-                if (!isempty(s)) {
-                        if (streq(name, "Name"))
-                                i->name = s;
-                        else if (streq(name, "Slice"))
-                                i->slice = s;
-                        else if (streq(name, "State"))
-                                i->state = s;
-                }
-                break;
-        }
-
-        case DBUS_TYPE_UINT32: {
-                uint32_t u;
-
-                dbus_message_iter_get_basic(iter, &u);
-
-                if (streq(name, "UID"))
-                        i->uid = (uid_t) u;
-
-                break;
-        }
-
-        case DBUS_TYPE_UINT64: {
-                uint64_t u;
-
-                dbus_message_iter_get_basic(iter, &u);
-
-                if (streq(name, "Timestamp"))
-                        i->timestamp = (usec_t) u;
-
-                break;
-        }
-
-        case DBUS_TYPE_STRUCT: {
-                DBusMessageIter sub;
-
-                dbus_message_iter_recurse(iter, &sub);
-
-                if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING && streq(name, "Display")) {
-                        const char *s;
-
-                        dbus_message_iter_get_basic(&sub, &s);
-
-                        if (!isempty(s))
-                                i->display = s;
-                }
-
-                break;
-        }
-
-        case DBUS_TYPE_ARRAY: {
-
-                if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Sessions")) {
-                        DBusMessageIter sub, sub2;
-
-                        dbus_message_iter_recurse(iter, &sub);
-                        while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
-                                const char *id;
-                                const char *path;
-
-                                dbus_message_iter_recurse(&sub, &sub2);
-
-                                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &id, true) >= 0 &&
-                                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &path, false) >= 0) {
-                                        char **l;
-
-                                        l = strv_append(i->sessions, id);
-                                        if (!l)
-                                                return -ENOMEM;
 
-                                        strv_free(i->sessions);
-                                        i->sessions = l;
-                                }
-
-                                dbus_message_iter_next(&sub);
-                        }
-
-                        return 0;
-                }
-        }
-        }
+finish:
+        strv_free(i.sessions);
 
         return 0;
 }
 
-static int status_property_seat(const char *name, DBusMessageIter *iter, SeatStatusInfo *i) {
-        assert(name);
-        assert(iter);
-        assert(i);
-
-        switch (dbus_message_iter_get_arg_type(iter)) {
-
-        case DBUS_TYPE_STRING: {
-                const char *s;
-
-                dbus_message_iter_get_basic(iter, &s);
-
-                if (!isempty(s)) {
-                        if (streq(name, "Id"))
-                                i->id = s;
-                }
-                break;
-        }
-
-        case DBUS_TYPE_STRUCT: {
-                DBusMessageIter sub;
-
-                dbus_message_iter_recurse(iter, &sub);
-
-                if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING && streq(name, "ActiveSession")) {
-                        const char *s;
-
-                        dbus_message_iter_get_basic(&sub, &s);
-
-                        if (!isempty(s))
-                                i->active_session = s;
-                }
-
-                break;
-        }
-
-        case DBUS_TYPE_ARRAY: {
-
-                if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Sessions")) {
-                        DBusMessageIter sub, sub2;
-
-                        dbus_message_iter_recurse(iter, &sub);
-                        while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
-                                const char *id;
-                                const char *path;
-
-                                dbus_message_iter_recurse(&sub, &sub2);
+static int show_session(sd_bus *bus, char **args, unsigned n) {
+        bool show_properties;
+        unsigned i;
+        int r;
 
-                                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &id, true) >= 0 &&
-                                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &path, false) >= 0) {
-                                        char **l;
+        assert(bus);
+        assert(args);
 
-                                        l = strv_append(i->sessions, id);
-                                        if (!l)
-                                                return -ENOMEM;
+        show_properties = !strstr(args[0], "status");
 
-                                        strv_free(i->sessions);
-                                        i->sessions = l;
-                                }
+        pager_open_if_enabled();
 
-                                dbus_message_iter_next(&sub);
-                        }
+        if (show_properties && n <= 1) {
+                /* If not argument is specified inspect the manager
+                 * itself */
+                r = bus_print_all_properties(bus, "org.freedesktop.login1", "/org/freedesktop/login1", NULL, arg_all);
+                if (r < 0)
+                        log_error("Failed to query login manager.");
 
-                        return 0;
-                }
-        }
+                return r;
         }
 
-        return 0;
-}
-
-static int print_property(const char *name, DBusMessageIter *iter) {
-        assert(name);
-        assert(iter);
-
-        if (arg_property && !strv_find(arg_property, name))
-                return 0;
-
-        switch (dbus_message_iter_get_arg_type(iter)) {
-
-        case DBUS_TYPE_STRUCT: {
-                DBusMessageIter sub;
-
-                dbus_message_iter_recurse(iter, &sub);
-
-                if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING &&
-                    (streq(name, "Display") || streq(name, "ActiveSession"))) {
-                        const char *s;
+        for (i = 1; i < n; i++) {
+                _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+                _cleanup_bus_message_unref_ sd_bus_message * reply = NULL;
+                const char *path = NULL;
 
-                        dbus_message_iter_get_basic(&sub, &s);
+                if (i != 1)
+                        printf("\n");
 
-                        if (arg_all || !isempty(s))
-                                printf("%s=%s\n", name, s);
-                        return 0;
+                r = sd_bus_call_method(
+                                bus,
+                                "org.freedesktop.login1",
+                                "/org/freedesktop/login1",
+                                "org.freedesktop.login1.Manager",
+                                "GetSession",
+                                &error, &reply,
+                                "s", args[i]);
+                if (r < 0) {
+                        log_error("Failed to get session: %s", bus_error_message(&error, r));
+                        return r;
                 }
-                break;
-        }
-
-        case DBUS_TYPE_ARRAY:
 
-                if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Sessions")) {
-                        DBusMessageIter sub, sub2;
-                        bool found = false;
+                r = sd_bus_message_read(reply, "o", &path);
+                if (r < 0)
+                        return log_parse_error(r);
 
-                        dbus_message_iter_recurse(iter, &sub);
-                        while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
-                                const char *id;
-                                const char *path;
-
-                                dbus_message_iter_recurse(&sub, &sub2);
-
-                                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &id, true) >= 0 &&
-                                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &path, false) >= 0) {
-                                        if (found)
-                                                printf(" %s", id);
-                                        else {
-                                                printf("%s=%s", name, id);
-                                                found = true;
-                                        }
-                                }
-
-                                dbus_message_iter_next(&sub);
-                        }
-
-                        if (!found && arg_all)
-                                printf("%s=\n", name);
-                        else if (found)
-                                printf("\n");
-
-                        return 0;
+                if (show_properties)
+                        r = bus_print_all_properties(bus, "org.freedesktop.login1", path, NULL, arg_all);
+                else
+                        r = print_session_status_info(bus, path);
+                if (r < 0) {
+                        log_error("Failed to query session: %s", strerror(-r));
+                        return r;
                 }
-
-                break;
         }
 
-        if (generic_print_property(name, iter, arg_all) > 0)
-                return 0;
-
-        if (arg_all)
-                printf("%s=[unprintable]\n", name);
-
         return 0;
 }
 
-static int show_one(const char *verb, DBusConnection *bus, const char *path, bool show_properties, bool *new_line) {
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
-        const char *interface = "";
+static int show_user(sd_bus *bus, char **args, unsigned n) {
+        bool show_properties;
+        unsigned i;
         int r;
-        DBusMessageIter iter, sub, sub2, sub3;
-        SessionStatusInfo session_info = {};
-        UserStatusInfo user_info = {};
-        SeatStatusInfo seat_info = {};
-
-        assert(path);
-        assert(new_line);
 
-        r = bus_method_call_with_reply(
-                        bus,
-                        "org.freedesktop.login1",
-                        path,
-                        "org.freedesktop.DBus.Properties",
-                        "GetAll",
-                        &reply,
-                        NULL,
-                        DBUS_TYPE_STRING, &interface,
-                        DBUS_TYPE_INVALID);
-        if (r < 0)
-                goto finish;
-
-        if (!dbus_message_iter_init(reply, &iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
-            dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_DICT_ENTRY)  {
-                log_error("Failed to parse reply.");
-                r = -EIO;
-                goto finish;
-        }
+        assert(bus);
+        assert(args);
 
-        dbus_message_iter_recurse(&iter, &sub);
+        show_properties = !strstr(args[0], "status");
 
-        if (*new_line)
-                printf("\n");
+        pager_open_if_enabled();
 
-        *new_line = true;
+        if (show_properties && n <= 1) {
+                /* If not argument is specified inspect the manager
+                 * itself */
+                r = bus_print_all_properties(bus, "org.freedesktop.login1", "/org/freedesktop/login1", NULL, arg_all);
+                if (r < 0)
+                        log_error("Failed to query login manager.");
 
-        while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
-                const char *name;
+                return r;
+        }
 
-                if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_DICT_ENTRY) {
-                        log_error("Failed to parse reply.");
-                        r = -EIO;
-                        goto finish;
-                }
+        for (i = 1; i < n; i++) {
+                _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+                _cleanup_bus_message_unref_ sd_bus_message * reply = NULL;
+                const char *path = NULL;
+                uid_t uid;
 
-                dbus_message_iter_recurse(&sub, &sub2);
+                if (i != 1)
+                        printf("\n");
 
-                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &name, true) < 0) {
-                        log_error("Failed to parse reply.");
-                        r = -EIO;
-                        goto finish;
+                r = get_user_creds((const char**) (args+i), &uid, NULL, NULL, NULL);
+                if (r < 0) {
+                        log_error("Failed to look up user %s: %s", args[i], strerror(-r));
+                        return r;
                 }
 
-                if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_VARIANT)  {
-                        log_error("Failed to parse reply.");
-                        r = -EIO;
-                        goto finish;
+                r = sd_bus_call_method(
+                                bus,
+                                "org.freedesktop.login1",
+                                "/org/freedesktop/login1",
+                                "org.freedesktop.login1.Manager",
+                                "GetUser",
+                                &error, &reply,
+                                "u", (uint32_t) uid);
+                if (r < 0) {
+                        log_error("Failed to get user: %s", bus_error_message(&error, r));
+                        return r;
                 }
 
-                dbus_message_iter_recurse(&sub2, &sub3);
+                r = sd_bus_message_read(reply, "o", &path);
+                if (r < 0)
+                        return log_parse_error(r);
 
                 if (show_properties)
-                        r = print_property(name, &sub3);
-                else if (strstr(verb, "session"))
-                        r = status_property_session(name, &sub3, &session_info);
-                else if (strstr(verb, "user"))
-                        r = status_property_user(name, &sub3, &user_info);
+                        r = bus_print_all_properties(bus, "org.freedesktop.login1", path, NULL, arg_all);
                 else
-                        r = status_property_seat(name, &sub3, &seat_info);
-
+                        r = print_user_status_info(bus, path);
                 if (r < 0) {
-                        log_error("Failed to parse reply.");
-                        goto finish;
+                        log_error("Failed to query user: %s", strerror(-r));
+                        return r;
                 }
-
-                dbus_message_iter_next(&sub);
         }
 
-        if (!show_properties) {
-                if (strstr(verb, "session"))
-                        print_session_status_info(bus, &session_info);
-                else if (strstr(verb, "user"))
-                        print_user_status_info(bus, &user_info);
-                else
-                        print_seat_status_info(&seat_info);
-        }
-
-        r = 0;
-
-finish:
-        strv_free(seat_info.sessions);
-        strv_free(user_info.sessions);
-
-        return r;
+        return 0;
 }
 
-static int show(DBusConnection *bus, char **args, unsigned n) {
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
-        int r, ret = 0;
-        DBusError error;
+static int show_seat(sd_bus *bus, char **args, unsigned n) {
+        bool show_properties;
         unsigned i;
-        bool show_properties, new_line = false;
+        int r;
 
         assert(bus);
         assert(args);
 
-        dbus_error_init(&error);
-
         show_properties = !strstr(args[0], "status");
 
         pager_open_if_enabled();
@@ -989,95 +717,61 @@ static int show(DBusConnection *bus, char **args, unsigned n) {
         if (show_properties && n <= 1) {
                 /* If not argument is specified inspect the manager
                  * itself */
+                r = bus_print_all_properties(bus, "org.freedesktop.login1", "/org/freedesktop/login1", NULL, arg_all);
+                if (r < 0)
+                        log_error("Failed to query login manager.");
 
-                ret = show_one(args[0], bus, "/org/freedesktop/login1", show_properties, &new_line);
-                goto finish;
+                return r;
         }
 
         for (i = 1; i < n; i++) {
+                _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+                _cleanup_bus_message_unref_ sd_bus_message * reply = NULL;
                 const char *path = NULL;
 
-                if (strstr(args[0], "session")) {
-
-                        ret = bus_method_call_with_reply (
-                                        bus,
-                                        "org.freedesktop.login1",
-                                        "/org/freedesktop/login1",
-                                        "org.freedesktop.login1.Manager",
-                                        "GetSession",
-                                        &reply,
-                                        NULL,
-                                        DBUS_TYPE_STRING, &args[i],
-                                        DBUS_TYPE_INVALID);
-
-                } else if (strstr(args[0], "user")) {
-                        uid_t uid;
-                        uint32_t u;
-
-                        ret = get_user_creds((const char**) (args+i), &uid, NULL, NULL, NULL);
-                        if (ret < 0) {
-                                log_error("User %s unknown.", args[i]);
-                                goto finish;
-                        }
-
-                        u = (uint32_t) uid;
-                        ret = bus_method_call_with_reply(
-                                        bus,
-                                        "org.freedesktop.login1",
-                                        "/org/freedesktop/login1",
-                                        "org.freedesktop.login1.Manager",
-                                        "GetUser",
-                                        &reply,
-                                        NULL,
-                                        DBUS_TYPE_UINT32, &u,
-                                        DBUS_TYPE_INVALID);
-
-                } else {
-
-                        ret = bus_method_call_with_reply(
-                                        bus,
-                                        "org.freedesktop.login1",
-                                        "/org/freedesktop/login1",
-                                        "org.freedesktop.login1.Manager",
-                                        "GetSeat",
-                                        &reply,
-                                        NULL,
-                                        DBUS_TYPE_STRING, &args[i],
-                                        DBUS_TYPE_INVALID);
+                if (i != 1)
+                        printf("\n");
 
+                r = sd_bus_call_method(
+                                bus,
+                                "org.freedesktop.login1",
+                                "/org/freedesktop/login1",
+                                "org.freedesktop.login1.Manager",
+                                "GetSeat",
+                                &error, &reply,
+                                "s", args[i]);
+                if (r < 0) {
+                        log_error("Failed to get seat: %s", bus_error_message(&error, r));
+                        return r;
                 }
 
-                if (ret < 0)
-                        goto finish;
+                r = sd_bus_message_read(reply, "o", &path);
+                if (r < 0)
+                        return log_parse_error(r);
 
-                if (!dbus_message_get_args(reply, &error,
-                                           DBUS_TYPE_OBJECT_PATH, &path,
-                                           DBUS_TYPE_INVALID)) {
-                        log_error("Failed to parse reply: %s", bus_error_message(&error));
-                        ret = -EIO;
-                        goto finish;
+                if (show_properties)
+                        r = bus_print_all_properties(bus, "org.freedesktop.login1", path, NULL, arg_all);
+                else
+                        r = print_seat_status_info(bus, path);
+                if (r < 0) {
+                        log_error("Failed to query seat: %s", strerror(-r));
+                        return r;
                 }
-
-                r = show_one(args[0], bus, path, show_properties, &new_line);
-                if (r != 0)
-                        ret = r;
         }
 
-finish:
-        dbus_error_free(&error);
-
-        return ret;
+        return 0;
 }
 
-static int activate(DBusConnection *bus, char **args, unsigned n) {
-        int ret = 0;
+static int activate(sd_bus *bus, char **args, unsigned n) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         unsigned i;
+        int r;
 
         assert(args);
 
         for (i = 1; i < n; i++) {
 
-                ret = bus_method_call_with_reply (
+                r = sd_bus_call_method (
                                 bus,
                                 "org.freedesktop.login1",
                                 "/org/freedesktop/login1",
@@ -1086,20 +780,21 @@ static int activate(DBusConnection *bus, char **args, unsigned n) {
                                 streq(args[0], "unlock-session")    ? "UnlockSession" :
                                 streq(args[0], "terminate-session") ? "TerminateSession" :
                                                                       "ActivateSession",
-                                NULL,
-                                NULL,
-                                DBUS_TYPE_STRING, &args[i],
-                                DBUS_TYPE_INVALID);
-                if (ret)
-                        goto finish;
+                                &error, NULL,
+                                "s", args[i]);
+                if (r < 0) {
+                        log_error("Failed to issue method call: %s", bus_error_message(&error, -r));
+                        return r;
+                }
         }
 
-finish:
-        return ret;
+        return 0;
 }
 
-static int kill_session(DBusConnection *bus, char **args, unsigned n) {
+static int kill_session(sd_bus *bus, char **args, unsigned n) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         unsigned i;
+        int r;
 
         assert(args);
 
@@ -1107,30 +802,29 @@ static int kill_session(DBusConnection *bus, char **args, unsigned n) {
                 arg_kill_who = "all";
 
         for (i = 1; i < n; i++) {
-                int r;
 
-                r = bus_method_call_with_reply (
+                r = sd_bus_call_method (
                         bus,
                         "org.freedesktop.login1",
                         "/org/freedesktop/login1",
                         "org.freedesktop.login1.Manager",
                         "KillSession",
-                        NULL,
-                        NULL,
-                        DBUS_TYPE_STRING, &args[i],
-                        DBUS_TYPE_STRING, &arg_kill_who,
-                        DBUS_TYPE_INT32, &arg_signal,
-                        DBUS_TYPE_INVALID);
-                if (r)
+                        &error, NULL,
+                        "ssi", args[i], arg_kill_who, arg_signal);
+                if (r < 0) {
+                        log_error("Could not kill session: %s", bus_error_message(&error, -r));
                         return r;
+                }
         }
 
         return 0;
 }
 
-static int enable_linger(DBusConnection *bus, char **args, unsigned n) {
+static int enable_linger(sd_bus *bus, char **args, unsigned n) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         unsigned i;
-        dbus_bool_t b, interactive = true;
+        bool b;
+        int r;
 
         assert(args);
 
@@ -1139,45 +833,40 @@ static int enable_linger(DBusConnection *bus, char **args, unsigned n) {
         b = streq(args[0], "enable-linger");
 
         for (i = 1; i < n; i++) {
-                uint32_t u;
                 uid_t uid;
-                int r;
 
                 r = get_user_creds((const char**) (args+i), &uid, NULL, NULL, NULL);
                 if (r < 0) {
-                        log_error("Failed to resolve user %s: %s", args[i], strerror(-r));
+                        log_error("Failed to look up user %s: %s", args[i], strerror(-r));
                         return r;
                 }
 
-                u = (uint32_t) uid;
-                r = bus_method_call_with_reply (
+                r = sd_bus_call_method (
                         bus,
                         "org.freedesktop.login1",
                         "/org/freedesktop/login1",
                         "org.freedesktop.login1.Manager",
                         "SetUserLinger",
-                        NULL,
-                        NULL,
-                        DBUS_TYPE_UINT32, &u,
-                        DBUS_TYPE_BOOLEAN, &b,
-                        DBUS_TYPE_BOOLEAN, &interactive,
-                        DBUS_TYPE_INVALID);
-                if (r)
+                        &error, NULL,
+                        "ubb", (uint32_t) uid, b, true);
+                if (r < 0) {
+                        log_error("Could not enable linger: %s", bus_error_message(&error, -r));
                         return r;
+                }
         }
 
         return 0;
 }
 
-static int terminate_user(DBusConnection *bus, char **args, unsigned n) {
+static int terminate_user(sd_bus *bus, char **args, unsigned n) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         unsigned i;
+        int r;
 
         assert(args);
 
         for (i = 1; i < n; i++) {
-                uint32_t u;
                 uid_t uid;
-                int r;
 
                 r = get_user_creds((const char**) (args+i), &uid, NULL, NULL, NULL);
                 if (r < 0) {
@@ -1185,26 +874,27 @@ static int terminate_user(DBusConnection *bus, char **args, unsigned n) {
                         return r;
                 }
 
-                u = (uint32_t) uid;
-                r = bus_method_call_with_reply (
+                r = sd_bus_call_method (
                         bus,
                         "org.freedesktop.login1",
                         "/org/freedesktop/login1",
                         "org.freedesktop.login1.Manager",
                         "TerminateUser",
-                        NULL,
-                        NULL,
-                        DBUS_TYPE_UINT32, &u,
-                        DBUS_TYPE_INVALID);
-                if (r)
+                        &error, NULL,
+                        "u", (uint32_t) uid);
+                if (r < 0) {
+                        log_error("Could not terminate user: %s", bus_error_message(&error, -r));
                         return r;
+                }
         }
 
         return 0;
 }
 
-static int kill_user(DBusConnection *bus, char **args, unsigned n) {
+static int kill_user(sd_bus *bus, char **args, unsigned n) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         unsigned i;
+        int r;
 
         assert(args);
 
@@ -1213,8 +903,6 @@ static int kill_user(DBusConnection *bus, char **args, unsigned n) {
 
         for (i = 1; i < n; i++) {
                 uid_t uid;
-                uint32_t u;
-                int r;
 
                 r = get_user_creds((const char**) (args+i), &uid, NULL, NULL, NULL);
                 if (r < 0) {
@@ -1222,110 +910,115 @@ static int kill_user(DBusConnection *bus, char **args, unsigned n) {
                         return r;
                 }
 
-                u = (uint32_t) uid;
-                r = bus_method_call_with_reply (
+                r = sd_bus_call_method (
                         bus,
                         "org.freedesktop.login1",
                         "/org/freedesktop/login1",
                         "org.freedesktop.login1.Manager",
                         "KillUser",
-                        NULL,
-                        NULL,
-                        DBUS_TYPE_UINT32, &u,
-                        DBUS_TYPE_INT32, &arg_signal,
-                        DBUS_TYPE_INVALID);
-                if (r)
+                        &error, NULL,
+                        "ui", (uint32_t) uid, arg_signal);
+                if (r < 0) {
+                        log_error("Could not kill user: %s", bus_error_message(&error, -r));
                         return r;
+                }
         }
 
         return 0;
 }
 
-static int attach(DBusConnection *bus, char **args, unsigned n) {
+static int attach(sd_bus *bus, char **args, unsigned n) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         unsigned i;
-        dbus_bool_t interactive = true;
+        int r;
 
         assert(args);
 
         polkit_agent_open_if_enabled();
 
         for (i = 2; i < n; i++) {
-                int r;
 
-                r = bus_method_call_with_reply (
+                r = sd_bus_call_method (
                         bus,
                         "org.freedesktop.login1",
                         "/org/freedesktop/login1",
                         "org.freedesktop.login1.Manager",
                         "AttachDevice",
-                        NULL,
-                        NULL,
-                        DBUS_TYPE_STRING, &args[1],
-                        DBUS_TYPE_STRING, &args[i],
-                        DBUS_TYPE_BOOLEAN, &interactive,
-                        DBUS_TYPE_INVALID);
-                if (r)
+                        &error, NULL,
+                        "ssb", args[1], args[i], true);
+
+                if (r < 0) {
+                        log_error("Could not attach device: %s", bus_error_message(&error, -r));
                         return r;
+                }
         }
 
         return 0;
 }
 
-static int flush_devices(DBusConnection *bus, char **args, unsigned n) {
-        dbus_bool_t interactive = true;
+static int flush_devices(sd_bus *bus, char **args, unsigned n) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+        int r;
 
         assert(args);
 
         polkit_agent_open_if_enabled();
 
-        return bus_method_call_with_reply (
+        r = sd_bus_call_method (
                         bus,
                         "org.freedesktop.login1",
                         "/org/freedesktop/login1",
                         "org.freedesktop.login1.Manager",
                         "FlushDevices",
-                        NULL,
-                        NULL,
-                        DBUS_TYPE_BOOLEAN, &interactive,
-                        DBUS_TYPE_INVALID);
+                        &error, NULL,
+                        "b", true);
+        if (r < 0)
+                log_error("Could not flush devices: %s", bus_error_message(&error, -r));
+
+        return r;
 }
 
-static int lock_sessions(DBusConnection *bus, char **args, unsigned n) {
-        assert(args);
+static int lock_sessions(sd_bus *bus, char **args, unsigned n) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+        int r;
 
-        polkit_agent_open_if_enabled();
+        assert(args);
 
-        return bus_method_call_with_reply (
+        r = sd_bus_call_method (
                         bus,
                         "org.freedesktop.login1",
                         "/org/freedesktop/login1",
                         "org.freedesktop.login1.Manager",
                         streq(args[0], "lock-sessions") ? "LockSessions" : "UnlockSessions",
-                        NULL,
-                        NULL,
-                        DBUS_TYPE_INVALID);
+                        &error, NULL,
+                        NULL);
+        if (r < 0)
+                log_error("Could not lock sessions: %s", bus_error_message(&error, -r));
+
+        return r;
 }
 
-static int terminate_seat(DBusConnection *bus, char **args, unsigned n) {
+static int terminate_seat(sd_bus *bus, char **args, unsigned n) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         unsigned i;
+        int r;
 
         assert(args);
 
         for (i = 1; i < n; i++) {
-                int r;
 
-                r = bus_method_call_with_reply (
+                r = sd_bus_call_method (
                         bus,
                         "org.freedesktop.login1",
                         "/org/freedesktop/login1",
                         "org.freedesktop.login1.Manager",
                         "TerminateSeat",
-                        NULL,
-                        NULL,
-                        DBUS_TYPE_STRING, &args[i],
-                        DBUS_TYPE_INVALID);
-                if (r)
+                        &error, NULL,
+                        "s", args[i]);
+                if (r < 0) {
+                        log_error("Could not terminate seat: %s", bus_error_message(&error, -r));
                         return r;
+                }
         }
 
         return 0;
@@ -1337,15 +1030,15 @@ static int help(void) {
                "Send control commands to or query the login manager.\n\n"
                "  -h --help              Show this help\n"
                "     --version           Show package version\n"
+               "     --no-pager          Do not pipe output into a pager\n"
+               "     --no-ask-password   Don't prompt for password\n"
+               "  -H --host=[USER@]HOST  Operate on remote host\n"
+               "  -M --machine=CONTAINER Operate on local container\n"
                "  -p --property=NAME     Show only properties by this name\n"
                "  -a --all               Show all properties, including empty ones\n"
-               "     --kill-who=WHO      Who to send signal to\n"
                "  -l --full              Do not ellipsize output\n"
-               "  -s --signal=SIGNAL     Which signal to send\n"
-               "     --no-ask-password   Don't prompt for password\n"
-               "  -H --host=[USER@]HOST  Show information for remote host\n"
-               "  -P --privileged        Acquire privileges before execution\n"
-               "     --no-pager          Do not pipe output into a pager\n\n"
+               "     --kill-who=WHO      Who to send signal to\n"
+               "  -s --signal=SIGNAL     Which signal to send\n\n"
                "Commands:\n"
                "  list-sessions                   List sessions\n"
                "  session-status [ID...]          Show session status\n"
@@ -1394,7 +1087,7 @@ static int parse_argv(int argc, char *argv[]) {
                 { "kill-who",        required_argument, NULL, ARG_KILL_WHO        },
                 { "signal",          required_argument, NULL, 's'                 },
                 { "host",            required_argument, NULL, 'H'                 },
-                { "privileged",      no_argument,       NULL, 'P'                 },
+                { "machine",         required_argument, NULL, 'M'                 },
                 { "no-ask-password", no_argument,       NULL, ARG_NO_ASK_PASSWORD },
                 {}
         };
@@ -1404,7 +1097,7 @@ static int parse_argv(int argc, char *argv[]) {
         assert(argc >= 0);
         assert(argv);
 
-        while ((c = getopt_long(argc, argv, "hp:als:H:P", options, NULL)) >= 0) {
+        while ((c = getopt_long(argc, argv, "hp:als:H:M:", options, NULL)) >= 0) {
 
                 switch (c) {
 
@@ -1461,13 +1154,14 @@ static int parse_argv(int argc, char *argv[]) {
                         }
                         break;
 
-                case 'P':
-                        arg_transport = TRANSPORT_POLKIT;
+                case 'H':
+                        arg_transport = BUS_TRANSPORT_REMOTE;
+                        arg_host = optarg;
                         break;
 
-                case 'H':
-                        arg_transport = TRANSPORT_SSH;
-                        parse_user_at_host(optarg, &arg_user, &arg_host);
+                case 'M':
+                        arg_transport = BUS_TRANSPORT_CONTAINER;
+                        arg_host = optarg;
                         break;
 
                 case '?':
@@ -1481,7 +1175,7 @@ static int parse_argv(int argc, char *argv[]) {
         return 1;
 }
 
-static int loginctl_main(DBusConnection *bus, int argc, char *argv[], DBusError *error) {
+static int loginctl_main(sd_bus *bus, int argc, char *argv[]) {
 
         static const struct {
                 const char* verb;
@@ -1491,11 +1185,11 @@ static int loginctl_main(DBusConnection *bus, int argc, char *argv[], DBusError
                         EQUAL
                 } argc_cmp;
                 const int argc;
-                int (* const dispatch)(DBusConnection *bus, char **args, unsigned n);
+                int (* const dispatch)(sd_bus *bus, char **args, unsigned n);
         } verbs[] = {
                 { "list-sessions",         LESS,   1, list_sessions     },
-                { "session-status",        MORE,   2, show              },
-                { "show-session",          MORE,   1, show              },
+                { "session-status",        MORE,   2, show_session      },
+                { "show-session",          MORE,   1, show_session      },
                 { "activate",              EQUAL,  2, activate          },
                 { "lock-session",          MORE,   2, activate          },
                 { "unlock-session",        MORE,   2, activate          },
@@ -1504,15 +1198,15 @@ static int loginctl_main(DBusConnection *bus, int argc, char *argv[], DBusError
                 { "terminate-session",     MORE,   2, activate          },
                 { "kill-session",          MORE,   2, kill_session      },
                 { "list-users",            EQUAL,  1, list_users        },
-                { "user-status",           MORE,   2, show              },
-                { "show-user",             MORE,   1, show              },
+                { "user-status",           MORE,   2, show_user         },
+                { "show-user",             MORE,   1, show_user         },
                 { "enable-linger",         MORE,   2, enable_linger     },
                 { "disable-linger",        MORE,   2, enable_linger     },
                 { "terminate-user",        MORE,   2, terminate_user    },
                 { "kill-user",             MORE,   2, kill_user         },
                 { "list-seats",            EQUAL,  1, list_seats        },
-                { "seat-status",           MORE,   2, show              },
-                { "show-seat",             MORE,   1, show              },
+                { "seat-status",           MORE,   2, show_seat         },
+                { "show-seat",             MORE,   1, show_seat         },
                 { "attach",                MORE,   3, attach            },
                 { "flush-devices",         EQUAL,  1, flush_devices     },
                 { "terminate-seat",        MORE,   2, terminate_seat    },
@@ -1523,7 +1217,6 @@ static int loginctl_main(DBusConnection *bus, int argc, char *argv[], DBusError
 
         assert(argc >= 0);
         assert(argv);
-        assert(error);
 
         left = argc - optind;
 
@@ -1576,58 +1269,33 @@ static int loginctl_main(DBusConnection *bus, int argc, char *argv[], DBusError
                 assert_not_reached("Unknown comparison operator.");
         }
 
-        if (!bus) {
-                log_error("Failed to get D-Bus connection: %s", error->message);
-                return -EIO;
-        }
-
         return verbs[i].dispatch(bus, argv + optind, left);
 }
 
-int main(int argc, char*argv[]) {
-        int r, retval = EXIT_FAILURE;
-        DBusConnection *bus = NULL;
-        DBusError error;
-
-        dbus_error_init(&error);
+int main(int argc, char *argv[]) {
+        _cleanup_bus_unref_ sd_bus *bus = NULL;
+        int r;
 
         setlocale(LC_ALL, "");
         log_parse_environment();
         log_open();
 
         r = parse_argv(argc, argv);
-        if (r < 0)
+        if (r <= 0)
                 goto finish;
-        else if (r == 0) {
-                retval = EXIT_SUCCESS;
+
+        r = bus_open_transport(arg_transport, arg_host, false, &bus);
+        if (r < 0) {
+                log_error("Failed to create bus connection: %s", strerror(-r));
                 goto finish;
         }
 
-        if (arg_transport == TRANSPORT_NORMAL)
-                bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
-        else if (arg_transport == TRANSPORT_POLKIT)
-                bus_connect_system_polkit(&bus, &error);
-        else if (arg_transport == TRANSPORT_SSH)
-                bus_connect_system_ssh(NULL, arg_host, &bus, &error);
-        else
-                assert_not_reached("Uh, invalid transport...");
-
-        r = loginctl_main(bus, argc, argv, &error);
-        retval = r < 0 ? EXIT_FAILURE : r;
+        r = loginctl_main(bus, argc, argv);
 
 finish:
-        if (bus) {
-                dbus_connection_flush(bus);
-                dbus_connection_close(bus);
-                dbus_connection_unref(bus);
-        }
-
-        dbus_error_free(&error);
-        dbus_shutdown();
+        pager_close();
 
         strv_free(arg_property);
 
-        pager_close();
-
-        return retval;
+        return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 }