[systemd-devel] [PATCH 7/7] systemctl: port to libsystemd-bus

Marc-Antoine Perennou Marc-Antoine at Perennou.com
Wed Nov 6 20:49:04 PST 2013


Signed-off-by: Marc-Antoine Perennou <Marc-Antoine at Perennou.com>
---
 Makefile.am               |    6 +-
 src/systemctl/systemctl.c | 2301 +++++++++++++++++----------------------------
 2 files changed, 862 insertions(+), 1445 deletions(-)

diff --git a/Makefile.am b/Makefile.am
index 6810cc1..3d187cf 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1793,16 +1793,12 @@ systemd_cgroups_agent_LDADD = \
 systemctl_SOURCES = \
 	src/systemctl/systemctl.c
 
-systemctl_CFLAGS = \
-	$(AM_CFLAGS) \
-	$(DBUS_CFLAGS)
-
 systemctl_LDADD = \
 	libsystemd-units.la \
 	libsystemd-label.la \
 	libsystemd-shared.la \
 	libsystemd-daemon.la \
-	libsystemd-dbus.la \
+	libsystemd-bus-internal.la \
 	libsystemd-logs.la
 
 # ------------------------------------------------------------------------------
diff --git a/src/systemctl/systemctl.c b/src/systemctl/systemctl.c
index 9d22aad..5295eac 100644
--- a/src/systemctl/systemctl.c
+++ b/src/systemctl/systemctl.c
@@ -4,6 +4,7 @@
   This file is part of systemd.
 
   Copyright 2010 Lennart Poettering
+  Copyright 2013 Marc-Antoine Perennou
 
   systemd is free software; you can redistribute it and/or modify it
   under the terms of the GNU Lesser General Public License as published by
@@ -34,12 +35,16 @@
 #include <sys/stat.h>
 #include <stddef.h>
 #include <sys/prctl.h>
-#include <dbus/dbus.h>
 
 #include <systemd/sd-daemon.h>
 #include <systemd/sd-shutdown.h>
 #include <systemd/sd-login.h>
 
+#include "sd-bus.h"
+#include "bus-util.h"
+#include "bus-message.h"
+#include "bus-error.h"
+
 #include "log.h"
 #include "util.h"
 #include "macro.h"
@@ -49,7 +54,6 @@
 #include "initreq.h"
 #include "path-util.h"
 #include "strv.h"
-#include "dbus-common.h"
 #include "cgroup-show.h"
 #include "cgroup-util.h"
 #include "list.h"
@@ -124,22 +128,31 @@ static enum action {
         ACTION_CANCEL_SHUTDOWN,
         _ACTION_MAX
 } arg_action = ACTION_SYSTEMCTL;
-static enum transport {
-        TRANSPORT_NORMAL,
-        TRANSPORT_SSH,
-        TRANSPORT_POLKIT
-} arg_transport = TRANSPORT_NORMAL;
+static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
 static char *arg_host = NULL;
 static char *arg_user = NULL;
 static unsigned arg_lines = 10;
 static OutputMode arg_output = OUTPUT_SHORT;
 static bool arg_plain = false;
 
-static bool private_bus = false;
-
-static int daemon_reload(DBusConnection *bus, char **args);
+static int daemon_reload(sd_bus *bus, char **args);
 static void halt_now(enum action a);
 
+static int log_method_call_failed(const char *what, sd_bus_error *error, int err) {
+        log_error("Failed to %s: %s", what, bus_error_message(error, err));
+        return -err;
+}
+
+static int log_reply_parse_failed(void) {
+        log_error("Failed to parse reply.");
+        return -EIO;
+}
+
+static int log_message_creation_failed(int err) {
+        log_error("Failed to create dbus message: %s", strerror(err));
+        return -err;
+}
+
 static void pager_open_if_enabled(void) {
 
         if (arg_no_pager)
@@ -176,26 +189,26 @@ static void polkit_agent_open_if_enabled(void) {
 }
 #endif
 
-static int translate_bus_error_to_exit_status(int r, const DBusError *error) {
+static int translate_bus_error_to_exit_status(int r, const sd_bus_error *error) {
         assert(error);
 
-        if (!dbus_error_is_set(error))
+        if (!sd_bus_error_is_set(error))
                 return r;
 
-        if (dbus_error_has_name(error, DBUS_ERROR_ACCESS_DENIED) ||
-            dbus_error_has_name(error, BUS_ERROR_ONLY_BY_DEPENDENCY) ||
-            dbus_error_has_name(error, BUS_ERROR_NO_ISOLATION) ||
-            dbus_error_has_name(error, BUS_ERROR_TRANSACTION_IS_DESTRUCTIVE))
+        if (sd_bus_error_has_name(error, SD_BUS_ERROR_ACCESS_DENIED) ||
+            sd_bus_error_has_name(error, BUS_ERROR_ONLY_BY_DEPENDENCY) ||
+            sd_bus_error_has_name(error, BUS_ERROR_NO_ISOLATION) ||
+            sd_bus_error_has_name(error, BUS_ERROR_TRANSACTION_IS_DESTRUCTIVE))
                 return EXIT_NOPERMISSION;
 
-        if (dbus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT))
+        if (sd_bus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT))
                 return EXIT_NOTINSTALLED;
 
-        if (dbus_error_has_name(error, BUS_ERROR_JOB_TYPE_NOT_APPLICABLE) ||
-            dbus_error_has_name(error, BUS_ERROR_NOT_SUPPORTED))
+        if (sd_bus_error_has_name(error, BUS_ERROR_JOB_TYPE_NOT_APPLICABLE) ||
+            sd_bus_error_has_name(error, BUS_ERROR_NOT_SUPPORTED))
                 return EXIT_NOTIMPLEMENTED;
 
-        if (dbus_error_has_name(error, BUS_ERROR_LOAD_FAILED))
+        if (sd_bus_error_has_name(error, BUS_ERROR_LOAD_FAILED))
                 return EXIT_NOTCONFIGURED;
 
         if (r != 0)
@@ -412,12 +425,11 @@ static void output_units_list(const struct unit_info *unit_infos, unsigned c) {
 }
 
 static int get_unit_list(
-                DBusConnection *bus,
-                DBusMessage **reply,
+                sd_bus *bus,
+                sd_bus_message **reply,
                 struct unit_info **unit_infos,
                 unsigned *c) {
-
-        DBusMessageIter iter, sub;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         size_t size = 0;
         int r;
 
@@ -425,42 +437,39 @@ static int get_unit_list(
         assert(unit_infos);
         assert(c);
 
-        r = bus_method_call_with_reply(
+        r = sd_bus_call_method(
                         bus,
                         "org.freedesktop.systemd1",
                         "/org/freedesktop/systemd1",
                         "org.freedesktop.systemd1.Manager",
                         "ListUnits",
+                        &error,
                         reply,
-                        NULL,
-                        DBUS_TYPE_INVALID);
+                        NULL);
         if (r < 0)
-                return r;
+                return log_method_call_failed("list units", &error, -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;
-        }
+        if (sd_bus_message_enter_container(*reply, SD_BUS_TYPE_ARRAY, "(ssssssouso)") < 0)
+                return log_reply_parse_failed();
 
-        dbus_message_iter_recurse(&iter, &sub);
-
-        while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
+        while (!sd_bus_message_at_end(*reply, false)) {
                 if (!GREEDY_REALLOC(*unit_infos, size, *c + 1))
                         return log_oom();
 
-                bus_parse_unit_info(&sub, *unit_infos + *c);
-                (*c)++;
+                if (bus_message_read_unit_info(*reply, *unit_infos + *c) < 0)
+                        return log_reply_parse_failed();
 
-                dbus_message_iter_next(&sub);
+                (*c)++;
         }
 
+        if (sd_bus_message_exit_container(*reply) < 0)
+                return log_reply_parse_failed();
+
         return 0;
 }
 
-static int list_units(DBusConnection *bus, char **args) {
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+static int list_units(sd_bus *bus, char **args) {
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
         _cleanup_free_ struct unit_info *unit_infos = NULL;
         unsigned c = 0;
         int r;
@@ -479,116 +488,58 @@ static int list_units(DBusConnection *bus, char **args) {
 }
 
 static int get_triggered_units(
-                DBusConnection *bus,
+                sd_bus *bus,
                 const char* unit_path,
                 char*** triggered) {
-
-        const char *interface = "org.freedesktop.systemd1.Unit",
-                   *triggers_property = "Triggers";
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
-        DBusMessageIter iter, sub;
+        char **ret = NULL;
         int r;
 
-        r = bus_method_call_with_reply(bus,
-                                       "org.freedesktop.systemd1",
-                                       unit_path,
-                                       "org.freedesktop.DBus.Properties",
-                                       "Get",
-                                       &reply,
-                                       NULL,
-                                       DBUS_TYPE_STRING, &interface,
-                                       DBUS_TYPE_STRING, &triggers_property,
-                                       DBUS_TYPE_INVALID);
-        if (r < 0)
+        r = bus_get_unit_property_strv(bus, unit_path, "Triggers", &ret);
+        if (r < 0) {
+                strv_free(ret);
+                log_error ("Failed get triggered units: %s", strerror(-r));
                 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 -EBADMSG;
-        }
-
-        dbus_message_iter_recurse(&iter, &sub);
-        dbus_message_iter_recurse(&sub, &iter);
-        sub = iter;
-
-        while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
-                const char *unit;
-
-                if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING) {
-                        log_error("Failed to parse reply.");
-                        return -EBADMSG;
-                }
-
-                dbus_message_iter_get_basic(&sub, &unit);
-                r = strv_extend(triggered, unit);
-                if (r < 0)
-                        return r;
-
-                dbus_message_iter_next(&sub);
-        }
+        } else
+                *triggered = ret;
 
         return 0;
 }
 
-static int get_listening(DBusConnection *bus, const char* unit_path,
-                         char*** listen, unsigned *c)
-{
-        const char *interface = "org.freedesktop.systemd1.Socket",
-                   *listen_property = "Listen";
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
-        DBusMessageIter iter, sub;
+static int get_listening(sd_bus *bus, const char* unit_path,
+                         char*** listen, unsigned *c) {
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+        const char *type, *path;
         int r;
 
-        r = bus_method_call_with_reply(bus,
-                                       "org.freedesktop.systemd1",
-                                       unit_path,
-                                       "org.freedesktop.DBus.Properties",
-                                       "Get",
-                                       &reply,
-                                       NULL,
-                                       DBUS_TYPE_STRING, &interface,
-                                       DBUS_TYPE_STRING, &listen_property,
-                                       DBUS_TYPE_INVALID);
+        r = sd_bus_get_property(
+                            bus,
+                            "org.freedesktop.systemd1",
+                            unit_path,
+                            "org.freedesktop.systemd1.Socket",
+                            "Listen",
+                            &error,
+                            &reply,
+                            "a(ss)");
         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 -EBADMSG;
-        }
+                return log_method_call_failed("get listening sockets", &error, -r);
 
-        dbus_message_iter_recurse(&iter, &sub);
-        dbus_message_iter_recurse(&sub, &iter);
-        sub = iter;
+        if (sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ss)") < 0)
+                return log_reply_parse_failed();
 
-        while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
-                DBusMessageIter sub2;
-                const char *type, *path;
-
-                if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
-                        log_error("Failed to parse reply.");
-                        return -EBADMSG;
-                }
-
-                dbus_message_iter_recurse(&sub, &sub2);
-
-                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &type, true) >= 0 &&
-                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, false) >= 0) {
-                        r = strv_extend(listen, type);
-                        if (r < 0)
-                                return r;
-
-                        r = strv_extend(listen, path);
-                        if (r < 0)
-                                return r;
+        while ((r = sd_bus_message_read(reply, "(ss)", &type, &path)) > 0) {
+                r = strv_extend(listen, type);
+                if (r < 0)
+                        return r;
 
-                        (*c) ++;
-                }
+                r = strv_extend(listen, path);
+                if (r < 0)
+                         return r;
 
-                dbus_message_iter_next(&sub);
+                (*c)++;
         }
+        if (r < 0 || sd_bus_message_exit_container(reply) < 0)
+                return log_reply_parse_failed();
 
         return 0;
 }
@@ -678,8 +629,8 @@ static int output_sockets_list(struct socket_info *socket_infos, unsigned cs) {
         return 0;
 }
 
-static int list_sockets(DBusConnection *bus, char **args) {
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+static int list_sockets(sd_bus *bus, char **args) {
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
         _cleanup_free_ struct unit_info *unit_infos = NULL;
         struct socket_info *socket_infos = NULL;
         const struct unit_info *u;
@@ -836,11 +787,13 @@ static void output_unit_file_list(const UnitFileList *units, unsigned c) {
                 printf("\n%u unit files listed.\n", n_shown);
 }
 
-static int list_unit_files(DBusConnection *bus, char **args) {
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+static int list_unit_files(sd_bus *bus, char **args) {
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         _cleanup_free_ UnitFileList *units = NULL;
-        DBusMessageIter iter, sub, sub2;
         unsigned c = 0, n_units = 0;
+        const char *state;
+        char *path;
         int r;
 
         pager_open_if_enabled();
@@ -875,32 +828,23 @@ static int list_unit_files(DBusConnection *bus, char **args) {
 
                 hashmap_free(h);
         } else {
-                r = bus_method_call_with_reply(
+                r = sd_bus_call_method(
                                 bus,
                                 "org.freedesktop.systemd1",
                                 "/org/freedesktop/systemd1",
                                 "org.freedesktop.systemd1.Manager",
                                 "ListUnitFiles",
+                                &error,
                                 &reply,
-                                NULL,
-                                DBUS_TYPE_INVALID);
+                                NULL);
                 if (r < 0)
-                        return r;
+                        return log_method_call_failed("list unit files", &error, -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;
-                }
+                if (sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ss)") < 0)
+                        return log_reply_parse_failed();
 
-                dbus_message_iter_recurse(&iter, &sub);
-
-                while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
+                while ((r = sd_bus_message_read(reply, "(ss)", &path, &state)) > 0) {
                         UnitFileList *u;
-                        const char *state;
-
-                        assert(dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT);
 
                         if (c >= n_units) {
                                 UnitFileList *w;
@@ -914,20 +858,13 @@ static int list_unit_files(DBusConnection *bus, char **args) {
                         }
 
                         u = units + c;
-
-                        dbus_message_iter_recurse(&sub, &sub2);
-
-                        if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->path, true) < 0 ||
-                            bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &state, false) < 0) {
-                                log_error("Failed to parse reply.");
-                                return -EIO;
-                        }
-
+                        u->path = path;
                         u->state = unit_file_state_from_string(state);
 
-                        dbus_message_iter_next(&sub);
                         c++;
                 }
+                if (r < 0 || sd_bus_message_exit_container(reply) < 0)
+                        return log_reply_parse_failed();
         }
 
         if (c > 0) {
@@ -974,7 +911,7 @@ static int list_dependencies_print(const char *name, int level, unsigned int bra
         return 0;
 }
 
-static int list_dependencies_get_dependencies(DBusConnection *bus, const char *name, char ***deps) {
+static int list_dependencies_get_dependencies(sd_bus *bus, const char *name, char ***deps) {
         static const char *dependencies[] = {
                 [DEPENDENCY_FORWARD] = "Requires\0"
                                        "RequiresOverridable\0"
@@ -989,101 +926,68 @@ static int list_dependencies_get_dependencies(DBusConnection *bus, const char *n
                 [DEPENDENCY_BEFORE]  = "Before\0",
         };
 
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         _cleanup_free_ char *path;
-        const char *interface = "org.freedesktop.systemd1.Unit";
-
-        _cleanup_dbus_message_unref_  DBusMessage *reply = NULL;
-        DBusMessageIter iter, sub, sub2, sub3;
-
-        int r = 0;
         char **ret = NULL;
+        int r;
 
         assert(bus);
         assert(name);
         assert(deps);
+        assert(arg_dependency < ELEMENTSOF(dependencies));
 
         path = unit_dbus_path_from_name(name);
-        if (path == NULL) {
-                r = -EINVAL;
-                goto finish;
-        }
+        if (path == NULL)
+                return -EINVAL;
 
-        r = bus_method_call_with_reply(
+        r = sd_bus_call_method(
                 bus,
                 "org.freedesktop.systemd1",
                 path,
                 "org.freedesktop.DBus.Properties",
                 "GetAll",
+                &error,
                 &reply,
-                NULL,
-                DBUS_TYPE_STRING, &interface,
-                DBUS_TYPE_INVALID);
+                "s", "org.freedesktop.systemd1.Unit");
         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;
-        }
+                return log_method_call_failed("get properties", &error, -r);
 
-        dbus_message_iter_recurse(&iter, &sub);
+        if (sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "{sv}") < 0)
+                return log_reply_parse_failed();
 
-        while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
+        while (!sd_bus_message_at_end(reply, false)) {
                 const char *prop;
 
-                assert(dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_DICT_ENTRY);
-                dbus_message_iter_recurse(&sub, &sub2);
+                if (sd_bus_message_enter_container(reply, SD_BUS_TYPE_DICT_ENTRY, "sv") < 0 ||
+                    sd_bus_message_read_basic(reply, SD_BUS_TYPE_STRING, &prop) < 0)
+                        goto fail;
 
-                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &prop, true) < 0) {
-                        log_error("Failed to parse reply.");
-                        r = -EIO;
-                        goto finish;
-                }
-
-                if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_VARIANT) {
-                        log_error("Failed to parse reply.");
-                        r = -EIO;
-                        goto finish;
+                if (!nulstr_contains(dependencies[arg_dependency], prop)) {
+                        if (sd_bus_message_skip(reply, "v") < 0)
+                                goto fail;
+                        goto next;
                 }
 
-                dbus_message_iter_recurse(&sub2, &sub3);
-                dbus_message_iter_next(&sub);
+                if (sd_bus_message_enter_container(reply, SD_BUS_TYPE_VARIANT, "as") < 0 ||
+                    bus_message_read_strv_extend(reply, &ret) < 0 ||
+                    sd_bus_message_exit_container(reply) < 0)
+                        goto fail;
 
-                assert(arg_dependency < ELEMENTSOF(dependencies));
-                if (!nulstr_contains(dependencies[arg_dependency], prop))
-                        continue;
-
-                if (dbus_message_iter_get_arg_type(&sub3) == DBUS_TYPE_ARRAY) {
-                        if (dbus_message_iter_get_element_type(&sub3) == DBUS_TYPE_STRING) {
-                                DBusMessageIter sub4;
-                                dbus_message_iter_recurse(&sub3, &sub4);
-
-                                while (dbus_message_iter_get_arg_type(&sub4) != DBUS_TYPE_INVALID) {
-                                        const char *s;
+next:
+                if (sd_bus_message_exit_container(reply) < 0)
+                        goto fail;
+        }
 
-                                        assert(dbus_message_iter_get_arg_type(&sub4) == DBUS_TYPE_STRING);
-                                        dbus_message_iter_get_basic(&sub4, &s);
+        if (sd_bus_message_exit_container(reply) < 0)
+                goto fail;
 
-                                        r = strv_extend(&ret, s);
-                                        if (r < 0) {
-                                                log_oom();
-                                                goto finish;
-                                        }
+        *deps = ret;
+        return 0;
 
-                                        dbus_message_iter_next(&sub4);
-                                }
-                        }
-                }
-        }
-finish:
-        if (r < 0)
-                strv_free(ret);
-        else
-                *deps = ret;
-        return r;
+fail:
+        strv_free(ret);
+        return log_reply_parse_failed();
 }
 
 static int list_dependencies_compare(const void *_a, const void *_b) {
@@ -1095,7 +999,7 @@ static int list_dependencies_compare(const void *_a, const void *_b) {
         return strcasecmp(*a, *b);
 }
 
-static int list_dependencies_one(DBusConnection *bus, const char *name, int level, char ***units, unsigned int branches) {
+static int list_dependencies_one(sd_bus *bus, const char *name, int level, char ***units, unsigned int branches) {
         _cleanup_strv_free_ char **deps = NULL, **u;
         char **c;
         int r = 0;
@@ -1138,7 +1042,7 @@ static int list_dependencies_one(DBusConnection *bus, const char *name, int leve
         return 0;
 }
 
-static int list_dependencies(DBusConnection *bus, char **args) {
+static int list_dependencies(sd_bus *bus, char **args) {
         _cleanup_free_ char *unit = NULL;
         _cleanup_strv_free_ char **units = NULL;
         const char *u;
@@ -1160,57 +1064,41 @@ static int list_dependencies(DBusConnection *bus, char **args) {
         return list_dependencies_one(bus, u, 0, &units, 0);
 }
 
-static int get_default(DBusConnection *bus, char **args) {
-        char *path = NULL;
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+static int get_default(sd_bus *bus, char **args) {
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+        _cleanup_free_ char *_path = NULL;
+        const char *path;
         int r;
-        _cleanup_dbus_error_free_ DBusError error;
-
-        dbus_error_init(&error);
 
         if (!bus || avoid_bus()) {
-                r = unit_file_get_default(arg_scope, arg_root, &path);
-
+                r = unit_file_get_default(arg_scope, arg_root, &_path);
                 if (r < 0) {
                         log_error("Operation failed: %s", strerror(-r));
-                        goto finish;
+                        return r;
                 }
-
-                r = 0;
+                path = _path;
         } else {
-                r = bus_method_call_with_reply(
+                r = sd_bus_call_method(
                         bus,
                         "org.freedesktop.systemd1",
                         "/org/freedesktop/systemd1",
                         "org.freedesktop.systemd1.Manager",
                         "GetDefaultTarget",
+                        &error,
                         &reply,
-                        NULL,
-                        DBUS_TYPE_INVALID);
-
-                if (r < 0) {
-                        log_error("Operation failed: %s", strerror(-r));
-                        goto finish;
-                }
+                        NULL);
+                if (r < 0)
+                        return log_method_call_failed("get default target", &error, -r);
 
-                if (!dbus_message_get_args(reply, &error,
-                                   DBUS_TYPE_STRING, &path,
-                                   DBUS_TYPE_INVALID)) {
-                        log_error("Failed to parse reply: %s", bus_error_message(&error));
-                        dbus_error_free(&error);
-                        return  -EIO;
-                }
+                if (sd_bus_message_read_basic(reply, SD_BUS_TYPE_STRING, &path) < 0)
+                        return log_reply_parse_failed();
         }
 
         if (path)
                 printf("%s\n", path);
 
-finish:
-        if ((!bus || avoid_bus()) && path)
-                free(path);
-
-        return r;
-
+        return 0;
 }
 
 struct job_info {
@@ -1285,56 +1173,31 @@ static void list_jobs_print(struct job_info* jobs, size_t n) {
                 printf("\n%s%zu jobs listed%s.\n", on, n, off);
 }
 
-static int list_jobs(DBusConnection *bus, char **args) {
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
-        DBusMessageIter iter, sub, sub2;
-        int r;
+static int list_jobs(sd_bus *bus, char **args) {
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         struct job_info *jobs = NULL;
         size_t size = 0, used = 0;
+        const char *name, *type, *state, *job_path, *unit_path;
+        uint32_t id;
+        int r;
 
-        r = bus_method_call_with_reply(
+        r = sd_bus_call_method(
                         bus,
                         "org.freedesktop.systemd1",
                         "/org/freedesktop/systemd1",
                         "org.freedesktop.systemd1.Manager",
                         "ListJobs",
+                        &error,
                         &reply,
-                        NULL,
-                        DBUS_TYPE_INVALID);
+                        NULL);
         if (r < 0)
-                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;
-        }
+                return log_method_call_failed("list jobs", &error, -r);
 
-        dbus_message_iter_recurse(&iter, &sub);
-
-        while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
-                const char *name, *type, *state, *job_path, *unit_path;
-                uint32_t id;
-
-                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);
-
-                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &id, true) < 0 ||
-                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &name, true) < 0 ||
-                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &type, true) < 0 ||
-                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &state, true) < 0 ||
-                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &job_path, true) < 0 ||
-                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &unit_path, false) < 0) {
-                        log_error("Failed to parse reply.");
-                        r = -EIO;
-                        goto finish;
-                }
+        if (sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(usssoo)") < 0)
+                return log_reply_parse_failed();
 
+        while ((r = sd_bus_message_read(reply, "(usssoo)", &id, &name, &type, &state, &job_path, &unit_path)) > 0) {
                 if (!GREEDY_REALLOC(jobs, size, used + 1)) {
                         r = log_oom();
                         goto finish;
@@ -1348,11 +1211,11 @@ static int list_jobs(DBusConnection *bus, char **args) {
                         r = log_oom();
                         goto finish;
                 }
-
-                dbus_message_iter_next(&sub);
         }
-
-        list_jobs_print(jobs, used);
+        if (r < 0)
+                r = log_method_call_failed("list jobs", &error, -r);
+        else
+                list_jobs_print(jobs, used);
 
  finish:
         while (used--) {
@@ -1362,10 +1225,11 @@ static int list_jobs(DBusConnection *bus, char **args) {
         }
         free(jobs);
 
-        return 0;
+        return r;
 }
 
-static int cancel_job(DBusConnection *bus, char **args) {
+static int cancel_job(sd_bus *bus, char **args) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         char **name;
 
         assert(args);
@@ -1383,87 +1247,63 @@ static int cancel_job(DBusConnection *bus, char **args) {
                         return r;
                 }
 
-                r = bus_method_call_with_reply(
+                r = sd_bus_call_method(
                                 bus,
                                 "org.freedesktop.systemd1",
                                 "/org/freedesktop/systemd1",
                                 "org.freedesktop.systemd1.Manager",
                                 "CancelJob",
+                                &error,
                                 NULL,
-                                NULL,
-                                DBUS_TYPE_UINT32, &id,
-                                DBUS_TYPE_INVALID);
+                                "u", id);
                 if (r < 0)
-                        return r;
+                        return log_method_call_failed("cancel job", &error, -r);
         }
 
         return 0;
 }
 
-static int need_daemon_reload(DBusConnection *bus, const char *unit) {
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
-        _cleanup_dbus_error_free_ DBusError error;
-        dbus_bool_t b = FALSE;
-        DBusMessageIter iter, sub;
-        const char
-                *interface = "org.freedesktop.systemd1.Unit",
-                *property = "NeedDaemonReload",
-                *path;
+static int need_daemon_reload(sd_bus *bus, const char *unit) {
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         _cleanup_free_ char *n = NULL;
+        const char *path;
+        bool b;
         int r;
 
-        dbus_error_init(&error);
-
         /* We ignore all errors here, since this is used to show a warning only */
 
         n = unit_name_mangle(unit);
         if (!n)
                 return log_oom();
 
-        r = bus_method_call_with_reply(
+        r = sd_bus_call_method(
                         bus,
                         "org.freedesktop.systemd1",
                         "/org/freedesktop/systemd1",
                         "org.freedesktop.systemd1.Manager",
                         "GetUnit",
-                        &reply,
                         &error,
-                        DBUS_TYPE_STRING, &n,
-                        DBUS_TYPE_INVALID);
+                        &reply,
+                        "s", n);
         if (r < 0)
-                return r;
-
-        if (!dbus_message_get_args(reply, NULL,
-                                   DBUS_TYPE_OBJECT_PATH, &path,
-                                   DBUS_TYPE_INVALID))
-                return -EIO;
+                return log_method_call_failed("get unit", &error, -r);
 
-        dbus_message_unref(reply);
-        reply = NULL;
+        if (sd_bus_message_read_basic (reply, SD_BUS_TYPE_OBJECT_PATH, &path) < 0)
+                return log_reply_parse_failed();
 
-        r = bus_method_call_with_reply(
+        r = sd_bus_get_property_basic(
                         bus,
                         "org.freedesktop.systemd1",
                         path,
-                        "org.freedesktop.DBus.Properties",
-                        "Get",
-                        &reply,
+                        "org.freedesktop.systemd1.Unit",
+                        "NeedDaemonReload",
                         &error,
-                        DBUS_TYPE_STRING, &interface,
-                        DBUS_TYPE_STRING, &property,
-                        DBUS_TYPE_INVALID);
+                        SD_BUS_TYPE_BOOLEAN,
+                        &b);
         if (r < 0)
-                return r;
-
-        if (!dbus_message_iter_init(reply, &iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
-                return -EIO;
-
-        dbus_message_iter_recurse(&iter, &sub);
-        if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN)
-                return -EIO;
+                return log_method_call_failed("get property", &error, -r);
 
-        dbus_message_iter_get_basic(&sub, &b);
         return b;
 }
 
@@ -1474,42 +1314,34 @@ typedef struct WaitData {
         char *result;
 } WaitData;
 
-static DBusHandlerResult wait_filter(DBusConnection *connection, DBusMessage *message, void *data) {
-        _cleanup_dbus_error_free_ DBusError error;
+static int wait_filter(sd_bus *bus, sd_bus_message *m, void *data) {
         WaitData *d = data;
 
-        dbus_error_init(&error);
-
-        assert(connection);
-        assert(message);
+        assert(bus);
+        assert(m);
         assert(d);
 
         log_debug("Got D-Bus request: %s.%s() on %s",
-                  dbus_message_get_interface(message),
-                  dbus_message_get_member(message),
-                  dbus_message_get_path(message));
+                  sd_bus_message_get_interface(m),
+                  sd_bus_message_get_member(m),
+                  sd_bus_message_get_path(m));
 
-        if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL, "Disconnected")) {
+        if (sd_bus_message_is_signal(m, "org.freedesktop.DBus.Local", "Disconnected")) {
                 log_error("Warning! D-Bus connection terminated.");
-                dbus_connection_close(connection);
-
-        } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "JobRemoved")) {
+                sd_bus_close(bus);
+        } else if (sd_bus_message_is_signal(m, "org.freedesktop.systemd1.Manager", "JobRemoved")) {
                 uint32_t id;
                 const char *path, *result, *unit;
-                char *r;
-
-                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)) {
+                char *ret;
+                int r;
 
-                        r = set_remove(d->set, (char*) path);
-                        if (!r)
-                                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+                r = sd_bus_message_read (m, "uoss", &id, &path, &unit, &result);
+                if (r >= 0) {
+                        ret = set_remove(d->set, (char*) path);
+                        if (!ret)
+                                return 0;
 
-                        free(r);
+                        free(ret);
 
                         if (!isempty(result))
                                 d->result = strdup(result);
@@ -1517,57 +1349,45 @@ static DBusHandlerResult wait_filter(DBusConnection *connection, DBusMessage *me
                         if (!isempty(unit))
                                 d->name = strdup(unit);
 
-                        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+                        return 0;
                 }
 #ifndef NOLEGACY
-                dbus_error_free(&error);
-                if (dbus_message_get_args(message, &error,
-                                          DBUS_TYPE_UINT32, &id,
-                                          DBUS_TYPE_OBJECT_PATH, &path,
-                                          DBUS_TYPE_STRING, &result,
-                                          DBUS_TYPE_INVALID)) {
-                        /* Compatibility with older systemd versions <
-                         * 183 during upgrades. This should be dropped
-                         * one day. */
-                        r = set_remove(d->set, (char*) path);
-                        if (!r)
-                                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-
-                        free(r);
+                r = sd_bus_message_read (m, "uos", &id, &path, &result);
+                if (r >= 0) {
+                        ret = set_remove(d->set, (char*) path);
+                        if (!ret)
+                                return 0;
+
+                        free(ret);
 
                         if (*result)
                                 d->result = strdup(result);
 
-                        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+                        return 0;
                 }
 #endif
 
-                log_error("Failed to parse message: %s", bus_error_message(&error));
+                log_error("Failed to parse message.");
         }
 
-        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+        return 0;
 }
 
-static int enable_wait_for_jobs(DBusConnection *bus) {
-        DBusError error;
+static int enable_wait_for_jobs(sd_bus *bus) {
+        int r;
 
         assert(bus);
 
-        if (private_bus)
-                return 0;
-
-        dbus_error_init(&error);
-        dbus_bus_add_match(bus,
-                           "type='signal',"
-                           "sender='org.freedesktop.systemd1',"
-                           "interface='org.freedesktop.systemd1.Manager',"
-                           "member='JobRemoved',"
-                           "path='/org/freedesktop/systemd1'",
-                           &error);
-
-        if (dbus_error_is_set(&error)) {
-                log_error("Failed to add match: %s", bus_error_message(&error));
-                dbus_error_free(&error);
+        r = sd_bus_add_match(
+                        bus,
+                        "type='signal',"
+                        "sender='org.freedesktop.systemd1',"
+                        "interface='org.freedesktop.systemd1.Manager',"
+                        "member='JobRemoved',"
+                        "path='/org/freedesktop/systemd1'",
+                        NULL, NULL);
+        if (r < 0) {
+                log_error("Failed to add match");
                 return -EIO;
         }
 
@@ -1575,21 +1395,27 @@ static int enable_wait_for_jobs(DBusConnection *bus) {
         return 0;
 }
 
-static int wait_for_jobs(DBusConnection *bus, Set *s) {
-        int r = 0;
+static int wait_for_jobs(sd_bus *bus, Set *s) {
         WaitData d = { .set = s };
+        int r;
 
         assert(bus);
         assert(s);
 
-        if (!dbus_connection_add_filter(bus, wait_filter, &d, NULL))
+        r = sd_bus_add_filter(bus, wait_filter, &d);
+        if (r < 0)
                 return log_oom();
 
         while (!set_isempty(s)) {
-
-                if (!dbus_connection_read_write_dispatch(bus, -1)) {
-                        log_error("Disconnected from bus.");
-                        return -ECONNREFUSED;
+                for(;;) {
+                        r = sd_bus_process(bus, NULL);
+                        if (r < 0)
+                                return r;
+                        if (r > 0)
+                                break;
+                        r = sd_bus_wait(bus, (uint64_t) -1);
+                        if (r < 0)
+                                return r;
                 }
 
                 if (!d.result)
@@ -1621,89 +1447,56 @@ static int wait_for_jobs(DBusConnection *bus, Set *s) {
                 d.name = NULL;
         }
 
-        dbus_connection_remove_filter(bus, wait_filter, &d);
-        return r;
+        return sd_bus_remove_filter(bus, wait_filter, &d);
 }
 
-static int check_one_unit(DBusConnection *bus, const char *name, char **check_states, bool quiet) {
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+static int check_one_unit(sd_bus *bus, const char *name, char **check_states, bool quiet) {
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         _cleanup_free_ char *n = NULL;
-        DBusMessageIter iter, sub;
-        const char
-                *interface = "org.freedesktop.systemd1.Unit",
-                *property = "ActiveState";
         const char *state, *path;
-        DBusError error;
         int r;
 
         assert(name);
 
-        dbus_error_init(&error);
-
         n = unit_name_mangle(name);
         if (!n)
                 return log_oom();
 
-        r = bus_method_call_with_reply (
+        r = sd_bus_call_method (
                         bus,
                         "org.freedesktop.systemd1",
                         "/org/freedesktop/systemd1",
                         "org.freedesktop.systemd1.Manager",
                         "GetUnit",
-                        &reply,
                         &error,
-                        DBUS_TYPE_STRING, &n,
-                        DBUS_TYPE_INVALID);
+                        &reply,
+                        "s", n);
         if (r < 0) {
-                dbus_error_free(&error);
-
+                log_method_call_failed("get unit", &error, -r);
                 if (!quiet)
                         puts("unknown");
                 return 0;
         }
 
-        if (!dbus_message_get_args(reply, NULL,
-                                   DBUS_TYPE_OBJECT_PATH, &path,
-                                   DBUS_TYPE_INVALID)) {
-                log_error("Failed to parse reply.");
-                return -EIO;
-        }
+        if (sd_bus_message_read_basic(reply, SD_BUS_TYPE_OBJECT_PATH, &path) < 0)
+                return log_reply_parse_failed();
 
-        dbus_message_unref(reply);
-        reply = NULL;
-
-        r = bus_method_call_with_reply(
+        r = sd_bus_get_property_basic(
                         bus,
                         "org.freedesktop.systemd1",
                         path,
-                        "org.freedesktop.DBus.Properties",
-                        "Get",
-                        &reply,
-                        NULL,
-                        DBUS_TYPE_STRING, &interface,
-                        DBUS_TYPE_STRING, &property,
-                        DBUS_TYPE_INVALID);
+                        "org.freedesktop.systemd1.Unit",
+                        "ActiveState",
+                        &error,
+                        SD_BUS_TYPE_STRING, &state);
         if (r < 0) {
+                log_method_call_failed("get unit state", &error, -r);
                 if (!quiet)
                         puts("unknown");
                 return 0;
         }
 
-        if (!dbus_message_iter_init(reply, &iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)  {
-                log_error("Failed to parse reply.");
-                return r;
-        }
-
-        dbus_message_iter_recurse(&iter, &sub);
-
-        if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING)  {
-                log_error("Failed to parse reply.");
-                return r;
-        }
-
-        dbus_message_iter_get_basic(&sub, &state);
-
         if (!quiet)
                 puts(state);
 
@@ -1711,17 +1504,19 @@ static int check_one_unit(DBusConnection *bus, const char *name, char **check_st
 }
 
 static void check_triggering_units(
-                DBusConnection *bus,
+                sd_bus *bus,
                 const char *unit_name) {
-
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
-        DBusMessageIter iter, sub;
-        const char *interface = "org.freedesktop.systemd1.Unit",
-                   *load_state_property = "LoadState",
-                   *triggered_by_property = "TriggeredBy",
-                   *state;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         _cleanup_free_ char *unit_path = NULL, *n = NULL;
+        _cleanup_strv_free_ char **triggered_by = NULL;
+        const char *state;
         bool print_warning_label = true;
+        char **service_trigger;
+        const char * const check_states[] = {
+                "active",
+                "reloading",
+                NULL
+        };
         int r;
 
         n = unit_name_mangle(unit_name);
@@ -1736,81 +1531,31 @@ static void check_triggering_units(
                 return;
         }
 
-        r = bus_method_call_with_reply(
+        r = sd_bus_get_property_basic(
                         bus,
                         "org.freedesktop.systemd1",
                         unit_path,
-                        "org.freedesktop.DBus.Properties",
-                        "Get",
-                        &reply,
-                        NULL,
-                        DBUS_TYPE_STRING, &interface,
-                        DBUS_TYPE_STRING, &load_state_property,
-                        DBUS_TYPE_INVALID);
-        if (r < 0)
-                return;
-
-        if (!dbus_message_iter_init(reply, &iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {
-                log_error("Failed to parse reply.");
+                        "org.freedesktop.systemd1.Unit",
+                        "LoadState",
+                        &error,
+                        SD_BUS_TYPE_STRING,
+                        &state);
+        if (r < 0) {
+                log_method_call_failed("load state", &error, -r);
                 return;
         }
 
-        dbus_message_iter_recurse(&iter, &sub);
-
-        if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING)  {
-            log_error("Failed to parse reply.");
-            return;
-        }
-
-        dbus_message_iter_get_basic(&sub, &state);
-
         if (streq(state, "masked"))
             return;
 
-        dbus_message_unref(reply);
-        reply = NULL;
-
-        r = bus_method_call_with_reply(
-                        bus,
-                        "org.freedesktop.systemd1",
-                        unit_path,
-                        "org.freedesktop.DBus.Properties",
-                        "Get",
-                        &reply,
-                        NULL,
-                        DBUS_TYPE_STRING, &interface,
-                        DBUS_TYPE_STRING, &triggered_by_property,
-                        DBUS_TYPE_INVALID);
-        if (r < 0)
-                return;
-
-        if (!dbus_message_iter_init(reply, &iter) ||
-            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {
-                log_error("Failed to parse reply.");
+        r = bus_get_unit_property_strv(bus, unit_path, "TriggeredBy", &triggered_by);
+        if (r < 0) {
+                log_method_call_failed("get triggers", &error, -r);
                 return;
         }
 
-        dbus_message_iter_recurse(&iter, &sub);
-        dbus_message_iter_recurse(&sub, &iter);
-        sub = iter;
-
-        while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
-                const char * const check_states[] = {
-                        "active",
-                        "reloading",
-                        NULL
-                };
-                const char *service_trigger;
-
-                if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING) {
-                        log_error("Failed to parse reply.");
-                        return;
-                }
-
-                dbus_message_iter_get_basic(&sub, &service_trigger);
-
-                r = check_one_unit(bus, service_trigger, (char**) check_states, true);
+        STRV_FOREACH(service_trigger, triggered_by) {
+                r = check_one_unit(bus, *service_trigger, (char**) check_states, true);
                 if (r < 0)
                         return;
                 if (r > 0) {
@@ -1819,22 +1564,19 @@ static void check_triggering_units(
                                 print_warning_label = false;
                         }
 
-                        log_warning("  %s", service_trigger);
+                        log_warning("  %s", *service_trigger);
                 }
-
-                dbus_message_iter_next(&sub);
         }
 }
 
 static int start_unit_one(
-                DBusConnection *bus,
+                sd_bus *bus,
                 const char *method,
                 const char *name,
                 const char *mode,
-                DBusError *error,
+                sd_bus_error *error,
                 Set *s) {
-
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
         _cleanup_free_ char *n;
         const char *path;
         int r;
@@ -1848,34 +1590,26 @@ static int start_unit_one(
         if (!n)
                 return log_oom();
 
-        r = bus_method_call_with_reply(
+        r = sd_bus_call_method(
                         bus,
                         "org.freedesktop.systemd1",
                         "/org/freedesktop/systemd1",
                         "org.freedesktop.systemd1.Manager",
                         method,
-                        &reply,
                         error,
-                        DBUS_TYPE_STRING, &n,
-                        DBUS_TYPE_STRING, &mode,
-                        DBUS_TYPE_INVALID);
-        if (r) {
+                        &reply,
+                        "ss", n, mode);
+        if (r < 0) {
                 if (r == -ENOENT && arg_action != ACTION_SYSTEMCTL)
                         /* There's always a fallback possible for
                          * legacy actions. */
-                        r = -EADDRNOTAVAIL;
+                        return -EADDRNOTAVAIL;
                 else
-                        log_error("Failed to issue method call: %s", bus_error_message(error));
-
-                return r;
+                        return log_method_call_failed("issue method call", 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));
-                return -EIO;
-        }
+        if (sd_bus_message_read_basic(reply, SD_BUS_TYPE_OBJECT_PATH, &path) < 0)
+                return log_reply_parse_failed();
 
         if (need_daemon_reload(bus, n) > 0)
                 log_warning("Warning: Unit file of %s changed on disk, 'systemctl %sdaemon-reload' recommended.",
@@ -1929,15 +1663,12 @@ static enum action verb_to_action(const char *verb) {
         return ACTION_INVALID;
 }
 
-static int start_unit(DBusConnection *bus, char **args) {
-
-        int r, ret = 0;
-        const char *method, *mode, *one_name;
+static int start_unit(sd_bus *bus, char **args) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         _cleanup_set_free_free_ Set *s = NULL;
-        _cleanup_dbus_error_free_ DBusError error;
+        const char *method, *mode, *one_name;
         char **name;
-
-        dbus_error_init(&error);
+        int r, ret = 0;
 
         assert(bus);
 
@@ -1967,7 +1698,6 @@ static int start_unit(DBusConnection *bus, char **args) {
                        action_table[action].mode ?: arg_job_mode;
 
                 one_name = action_table[action].target;
-
         } else {
                 assert(arg_action < ELEMENTSOF(action_table));
                 assert(action_table[arg_action].target);
@@ -1997,10 +1727,8 @@ static int start_unit(DBusConnection *bus, char **args) {
         } else {
                 STRV_FOREACH(name, args+1) {
                         r = start_unit_one(bus, method, *name, mode, &error, s);
-                        if (r < 0) {
+                        if (r < 0)
                                 ret = translate_bus_error_to_exit_status(r, &error);
-                                dbus_error_free(&error);
-                        }
                 }
         }
 
@@ -2025,10 +1753,11 @@ static int start_unit(DBusConnection *bus, char **args) {
 
 /* Ask systemd-logind, which might grant access to unprivileged users
  * through PolicyKit */
-static int reboot_with_logind(DBusConnection *bus, enum action a) {
+static int reboot_with_logind(sd_bus *bus, enum action a) {
 #ifdef HAVE_LOGIND
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         const char *method;
-        dbus_bool_t interactive = true;
+        int r;
 
         if (!bus)
                 return -EIO;
@@ -2061,29 +1790,34 @@ static int reboot_with_logind(DBusConnection *bus, enum action a) {
                 return -EINVAL;
         }
 
-        return bus_method_call_with_reply(
+        r = sd_bus_call_method(
                         bus,
                         "org.freedesktop.login1",
                         "/org/freedesktop/login1",
                         "org.freedesktop.login1.Manager",
                         method,
+                        &error,
                         NULL,
-                        NULL,
-                        DBUS_TYPE_BOOLEAN, &interactive,
-                        DBUS_TYPE_INVALID);
+                        "b", true);
+        if (r < 0)
+                return log_method_call_failed("issue method call", &error, -r);
+
+        return r;
 #else
         return -ENOSYS;
 #endif
 }
 
-static int check_inhibitors(DBusConnection *bus, enum action a) {
+static int check_inhibitors(sd_bus *bus, enum action a) {
 #ifdef HAVE_LOGIND
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
-        DBusMessageIter iter, sub, sub2;
-        int r;
-        unsigned c = 0;
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         _cleanup_strv_free_ char **sessions = NULL;
+        const char *what, *who, *why, *mode;
+        uint32_t uid, pid;
+        unsigned c = 0;
         char **s;
+        int r;
 
         if (!bus)
                 return 0;
@@ -2100,52 +1834,28 @@ static int check_inhibitors(DBusConnection *bus, enum action a) {
         if (!on_tty())
                 return 0;
 
-        r = bus_method_call_with_reply(
+        r = sd_bus_call_method(
                         bus,
                         "org.freedesktop.login1",
                         "/org/freedesktop/login1",
                         "org.freedesktop.login1.Manager",
                         "ListInhibitors",
+                        &error,
                         &reply,
-                        NULL,
-                        DBUS_TYPE_INVALID);
+                        NULL);
         if (r < 0)
                 /* If logind is not around, then there are no inhibitors... */
                 return 0;
 
-        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;
-        }
+        if (sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "ssssuu") < 0)
+                return log_reply_parse_failed();
 
-        dbus_message_iter_recurse(&iter, &sub);
-        while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
-                const char *what, *who, *why, *mode;
-                uint32_t uid, pid;
+        while ((r = sd_bus_message_read(reply, "ssssuu", &what, &who, &why, &mode, &uid, &pid)) > 0) {
                 _cleanup_strv_free_ char **sv = NULL;
                 _cleanup_free_ char *comm = NULL, *user = NULL;
 
-                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);
-
-                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &what, true) < 0 ||
-                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &who, true) < 0 ||
-                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &why, true) < 0 ||
-                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &mode, true) < 0 ||
-                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &uid, true) < 0 ||
-                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &pid, false) < 0) {
-                        log_error("Failed to parse reply.");
-                        return -EIO;
-                }
-
                 if (!streq(mode, "block"))
-                        goto next;
+                        continue;
 
                 sv = strv_split(what, ":");
                 if (!sv)
@@ -2156,24 +1866,20 @@ static int check_inhibitors(DBusConnection *bus, enum action a) {
                                   a == ACTION_POWEROFF ||
                                   a == ACTION_REBOOT ||
                                   a == ACTION_KEXEC ? "shutdown" : "sleep"))
-                        goto next;
+                        continue;
 
                 get_process_comm(pid, &comm);
                 user = uid_to_name(uid);
                 log_warning("Operation inhibited by \"%s\" (PID %lu \"%s\", user %s), reason is \"%s\".",
                             who, (unsigned long) pid, strna(comm), strna(user), why);
                 c++;
-
-        next:
-                dbus_message_iter_next(&sub);
         }
-
-        dbus_message_iter_recurse(&iter, &sub);
+        if (r < 0 || sd_bus_message_exit_container(reply) < 0)
+                return log_reply_parse_failed();
 
         /* Check for current sessions */
         sd_get_sessions(&sessions);
         STRV_FOREACH(s, sessions) {
-                uid_t uid;
                 _cleanup_free_ char *type = NULL, *tty = NULL, *seat = NULL, *user = NULL, *service = NULL, *class = NULL;
 
                 if (sd_session_get_uid(*s, &uid) < 0 || uid == getuid())
@@ -2206,7 +1912,7 @@ static int check_inhibitors(DBusConnection *bus, enum action a) {
 #endif
 }
 
-static int start_special(DBusConnection *bus, char **args) {
+static int start_special(sd_bus *bus, char **args) {
         enum action a;
         int r;
 
@@ -2256,7 +1962,7 @@ static int start_special(DBusConnection *bus, char **args) {
         return r;
 }
 
-static int check_unit_active(DBusConnection *bus, char **args) {
+static int check_unit_active(sd_bus *bus, char **args) {
         const char * const check_states[] = {
                 "active",
                 "reloading",
@@ -2282,7 +1988,7 @@ static int check_unit_active(DBusConnection *bus, char **args) {
         return r;
 }
 
-static int check_unit_failed(DBusConnection *bus, char **args) {
+static int check_unit_failed(sd_bus *bus, char **args) {
         const char * const check_states[] = {
                 "failed",
                 NULL
@@ -2307,7 +2013,8 @@ static int check_unit_failed(DBusConnection *bus, char **args) {
         return r;
 }
 
-static int kill_unit(DBusConnection *bus, char **args) {
+static int kill_unit(sd_bus *bus, char **args) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         char **name;
         int r = 0;
 
@@ -2324,20 +2031,17 @@ static int kill_unit(DBusConnection *bus, char **args) {
                 if (!n)
                         return log_oom();
 
-                r = bus_method_call_with_reply(
+                r = sd_bus_call_method(
                                 bus,
                                 "org.freedesktop.systemd1",
                                 "/org/freedesktop/systemd1",
                                 "org.freedesktop.systemd1.Manager",
                                 "KillUnit",
+                                &error,
                                 NULL,
-                                NULL,
-                                DBUS_TYPE_STRING, &n,
-                                DBUS_TYPE_STRING, &arg_kill_who,
-                                DBUS_TYPE_INT32, &arg_signal,
-                                DBUS_TYPE_INVALID);
+                                "ssi", n, arg_kill_who, arg_signal);
                 if (r < 0)
-                        return r;
+                        return log_method_call_failed("kill unit", &error, -r);
         }
         return 0;
 }
@@ -2368,72 +2072,36 @@ static void exec_status_info_free(ExecStatusInfo *i) {
         free(i);
 }
 
-static int exec_status_info_deserialize(DBusMessageIter *sub, ExecStatusInfo *i) {
+static int exec_status_info_deserialize(sd_bus_message *m, ExecStatusInfo *i) {
         uint64_t start_timestamp, exit_timestamp, start_timestamp_monotonic, exit_timestamp_monotonic;
-        DBusMessageIter sub2, sub3;
-        const char*path;
-        unsigned n;
+        const char *path;
         uint32_t pid;
         int32_t code, status;
-        dbus_bool_t ignore;
+        bool ignore;
+        int r;
 
-        assert(i);
+        assert(m);
         assert(i);
 
-        if (dbus_message_iter_get_arg_type(sub) != DBUS_TYPE_STRUCT)
-                return -EIO;
-
-        dbus_message_iter_recurse(sub, &sub2);
+        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_STRUCT, "sasbttttuii");
+        if (r < 0)
+                return log_reply_parse_failed();
+        else if (r == 0)
+                return 0;
 
-        if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, true) < 0)
-                return -EIO;
+        if (sd_bus_message_read_basic(m, SD_BUS_TYPE_STRING, &path) < 0)
+                return log_reply_parse_failed();
 
         i->path = strdup(path);
         if (!i->path)
                 return -ENOMEM;
 
-        if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_ARRAY ||
-            dbus_message_iter_get_element_type(&sub2) != DBUS_TYPE_STRING)
-                return -EIO;
-
-        n = 0;
-        dbus_message_iter_recurse(&sub2, &sub3);
-        while (dbus_message_iter_get_arg_type(&sub3) != DBUS_TYPE_INVALID) {
-                assert(dbus_message_iter_get_arg_type(&sub3) == DBUS_TYPE_STRING);
-                dbus_message_iter_next(&sub3);
-                n++;
-        }
-
-        i->argv = new0(char*, n+1);
-        if (!i->argv)
-                return -ENOMEM;
-
-        n = 0;
-        dbus_message_iter_recurse(&sub2, &sub3);
-        while (dbus_message_iter_get_arg_type(&sub3) != DBUS_TYPE_INVALID) {
-                const char *s;
-
-                assert(dbus_message_iter_get_arg_type(&sub3) == DBUS_TYPE_STRING);
-                dbus_message_iter_get_basic(&sub3, &s);
-                dbus_message_iter_next(&sub3);
-
-                i->argv[n] = strdup(s);
-                if (!i->argv[n])
-                        return -ENOMEM;
-
-                n++;
-        }
-
-        if (!dbus_message_iter_next(&sub2) ||
-            bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_BOOLEAN, &ignore, true) < 0 ||
-            bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &start_timestamp, true) < 0 ||
-            bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &start_timestamp_monotonic, true) < 0 ||
-            bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &exit_timestamp, true) < 0 ||
-            bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &exit_timestamp_monotonic, true) < 0 ||
-            bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &pid, true) < 0 ||
-            bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_INT32, &code, true) < 0 ||
-            bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_INT32, &status, false) < 0)
-                return -EIO;
+        if (sd_bus_message_read_strv(m, &i->argv) < 0 ||
+            sd_bus_message_read(m, "bttttuii", &ignore,
+                        &start_timestamp, &start_timestamp_monotonic,
+                        &exit_timestamp, &exit_timestamp_monotonic,
+                        &pid, &code, &status) < 0)
+                return log_reply_parse_failed();
 
         i->ignore = ignore;
         i->start_timestamp = (usec_t) start_timestamp;
@@ -2442,7 +2110,10 @@ static int exec_status_info_deserialize(DBusMessageIter *sub, ExecStatusInfo *i)
         i->code = code;
         i->status = status;
 
-        return 0;
+        if (sd_bus_message_exit_container(m) < 0)
+                return log_reply_parse_failed();
+
+        return 1;
 }
 
 typedef struct UnitStatusInfo {
@@ -2758,7 +2429,7 @@ static void print_status_info(UnitStatusInfo *i,
 
                 printf("   CGroup: %s\n", i->control_group);
 
-                if (arg_transport != TRANSPORT_SSH) {
+                if (arg_transport != BUS_TRANSPORT_REMOTE) {
                         unsigned k = 0;
                         pid_t extra[2];
                         char prefix[] = "           ";
@@ -2780,7 +2451,7 @@ static void print_status_info(UnitStatusInfo *i,
                 }
         }
 
-        if (i->id && arg_transport != TRANSPORT_SSH) {
+        if (i->id && arg_transport != BUS_TRANSPORT_REMOTE) {
                 printf("\n");
                 show_journal_by_unit(stdout,
                                      i->id,
@@ -2857,18 +2528,19 @@ static void show_unit_help(UnitStatusInfo *i) {
         }
 }
 
-static int status_property(const char *name, DBusMessageIter *iter, UnitStatusInfo *i) {
+static int status_property(const char *name, sd_bus_message *m, UnitStatusInfo *i, const char *contents) {
+        int r;
 
         assert(name);
-        assert(iter);
+        assert(m);
         assert(i);
 
-        switch (dbus_message_iter_get_arg_type(iter)) {
-
-        case DBUS_TYPE_STRING: {
+        switch (contents[0]) {
+        case SD_BUS_TYPE_STRING: {
                 const char *s;
 
-                dbus_message_iter_get_basic(iter, &s);
+                if (sd_bus_message_read_basic(m, SD_BUS_TYPE_STRING, &s) < 0)
+                        return log_reply_parse_failed();
 
                 if (!isempty(s)) {
                         if (streq(name, "Id"))
@@ -2915,11 +2587,11 @@ static int status_property(const char *name, DBusMessageIter *iter, UnitStatusIn
 
                 break;
         }
+        case SD_BUS_TYPE_BOOLEAN: {
+                bool b;
 
-        case DBUS_TYPE_BOOLEAN: {
-                dbus_bool_t b;
-
-                dbus_message_iter_get_basic(iter, &b);
+                if (sd_bus_message_read_basic(m, SD_BUS_TYPE_BOOLEAN, &b) < 0)
+                        return log_reply_parse_failed();
 
                 if (streq(name, "Accept"))
                         i->accept = b;
@@ -2930,11 +2602,11 @@ static int status_property(const char *name, DBusMessageIter *iter, UnitStatusIn
 
                 break;
         }
-
-        case DBUS_TYPE_UINT32: {
+        case SD_BUS_TYPE_UINT32: {
                 uint32_t u;
 
-                dbus_message_iter_get_basic(iter, &u);
+                if (sd_bus_message_read_basic(m, SD_BUS_TYPE_UINT32, &u) < 0)
+                        return log_reply_parse_failed();
 
                 if (streq(name, "MainPID")) {
                         if (u > 0) {
@@ -2953,11 +2625,11 @@ static int status_property(const char *name, DBusMessageIter *iter, UnitStatusIn
 
                 break;
         }
-
-        case DBUS_TYPE_INT32: {
+        case SD_BUS_TYPE_INT32: {
                 int32_t j;
 
-                dbus_message_iter_get_basic(iter, &j);
+                if (sd_bus_message_read_basic(m, SD_BUS_TYPE_INT32, &j) < 0)
+                        return log_reply_parse_failed();
 
                 if (streq(name, "ExecMainCode"))
                         i->exit_code = (int) j;
@@ -2966,11 +2638,11 @@ static int status_property(const char *name, DBusMessageIter *iter, UnitStatusIn
 
                 break;
         }
-
-        case DBUS_TYPE_UINT64: {
+        case SD_BUS_TYPE_UINT64: {
                 uint64_t u;
 
-                dbus_message_iter_get_basic(iter, &u);
+                if (sd_bus_message_read_basic(m, SD_BUS_TYPE_UINT64, &u) < 0)
+                        return log_reply_parse_failed();
 
                 if (streq(name, "ExecMainStartTimestamp"))
                         i->start_timestamp = (usec_t) u;
@@ -2991,156 +2663,109 @@ static int status_property(const char *name, DBusMessageIter *iter, UnitStatusIn
 
                 break;
         }
+        case SD_BUS_TYPE_ARRAY: {
+                if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && startswith(name, "Exec")) {
+                        _cleanup_free_ ExecStatusInfo *info = NULL;
 
-        case DBUS_TYPE_ARRAY: {
+                        if (sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sasbttttuii)") < 0)
+                                return log_reply_parse_failed();
 
-                if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT &&
-                    startswith(name, "Exec")) {
-                        DBusMessageIter sub;
+                        info = new0(ExecStatusInfo, 1);
+                        if (!info)
+                                return -ENOMEM;
 
-                        dbus_message_iter_recurse(iter, &sub);
-                        while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
-                                ExecStatusInfo *info;
-                                int r;
+                        while ((r = exec_status_info_deserialize(m, info)) > 0) {
+                            info->name = strdup(name);
+                            if (!info->name)
+                                    return -ENOMEM;
 
-                                info = new0(ExecStatusInfo, 1);
-                                if (!info)
-                                        return -ENOMEM;
+                            LIST_PREPEND(exec, i->exec, info);
 
-                                info->name = strdup(name);
-                                if (!info->name) {
-                                        free(info);
-                                        return -ENOMEM;
-                                }
-
-                                r = exec_status_info_deserialize(&sub, info);
-                                if (r < 0) {
-                                        free(info);
-                                        return r;
-                                }
-
-                                LIST_PREPEND(exec, i->exec, info);
-
-                                dbus_message_iter_next(&sub);
-                        }
-
-                } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT &&
-                           streq(name, "Listen")) {
-                        DBusMessageIter sub, sub2;
-
-                        dbus_message_iter_recurse(iter, &sub);
-                        while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
-                                const char *type, *path;
-
-                                dbus_message_iter_recurse(&sub, &sub2);
-
-                                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &type, true) >= 0 &&
-                                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, false) >= 0) {
-                                        int r;
-
-                                        r = strv_extend(&i->listen, type);
-                                        if (r < 0)
-                                                return r;
-                                        r = strv_extend(&i->listen, path);
-                                        if (r < 0)
-                                                return r;
-                                }
-
-                                dbus_message_iter_next(&sub);
+                            info = new0(ExecStatusInfo, 1);
+                            if (!info)
+                                    return -ENOMEM;
                         }
+                        if (r < 0 || sd_bus_message_exit_container(m) < 0)
+                                return log_reply_parse_failed();
 
                         return 0;
+                } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Listen")) {
+                        const char *type, *path;
 
-                } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRING &&
-                           streq(name, "DropInPaths")) {
-                        int r = bus_parse_strv_iter(iter, &i->dropin_paths);
-                        if (r < 0)
-                                return r;
+                        if (sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ss)") < 0)
+                                return log_reply_parse_failed();
 
-                } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRING &&
-                           streq(name, "Documentation")) {
-
-                        DBusMessageIter sub;
-
-                        dbus_message_iter_recurse(iter, &sub);
-                        while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING) {
-                                const char *s;
-                                int r;
-
-                                dbus_message_iter_get_basic(&sub, &s);
-
-                                r = strv_extend(&i->documentation, s);
+                        while ((r = sd_bus_message_read(m, "(ss)", &type, &path)) > 0) {
+                                r = strv_extend(&i->listen, type);
+                                if (r < 0)
+                                        return r;
+                                r = strv_extend(&i->listen, path);
                                 if (r < 0)
                                         return r;
-
-                                dbus_message_iter_next(&sub);
                         }
+                        if (r < 0 || sd_bus_message_exit_container(m) < 0)
+                                return log_reply_parse_failed();
 
-                } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT &&
-                           streq(name, "Conditions")) {
-                        DBusMessageIter sub, sub2;
-
-                        dbus_message_iter_recurse(iter, &sub);
-                        while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
-                                const char *cond, *param;
-                                dbus_bool_t trigger, negate;
-                                dbus_int32_t state;
-
-                                dbus_message_iter_recurse(&sub, &sub2);
-                                log_debug("here");
-
-                                if(bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &cond, true) >= 0 &&
-                                   bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_BOOLEAN, &trigger, true) >= 0 &&
-                                   bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_BOOLEAN, &negate, true) >= 0 &&
-                                   bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &param, true) >= 0 &&
-                                   bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_INT32, &state, false) >= 0) {
-                                        log_debug("%s %d %d %s %d", cond, trigger, negate, param, state);
-                                        if (state < 0 && (!trigger || !i->failed_condition)) {
-                                                i->failed_condition = cond;
-                                                i->failed_condition_trigger = trigger;
-                                                i->failed_condition_negate = negate;
-                                                i->failed_condition_param = param;
-                                        }
+                        return 0;
+                } else if (contents[1] == SD_BUS_TYPE_STRING && streq(name, "DropInPaths")) {
+                        if (sd_bus_message_read_strv(m, &i->dropin_paths) < 0)
+                                return log_reply_parse_failed();
+                } else if (contents[1] == SD_BUS_TYPE_STRING && streq(name, "Documentation")) {
+                        if (sd_bus_message_read_strv(m, &i->documentation) < 0)
+                                return log_reply_parse_failed();
+                } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Conditions")) {
+                        const char *cond, *param;
+                        bool trigger, negate;
+                        int32_t state;
+
+                        if (sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sbbsi)") < 0)
+                                return log_reply_parse_failed();
+
+                        while ((r = sd_bus_message_read(m, "(sbbsi)", &cond, &trigger, &negate, &param, &state)) > 0) {
+                                log_debug("%s %d %d %s %d", cond, trigger, negate, param, state);
+                                if (state < 0 && (!trigger || !i->failed_condition)) {
+                                        i->failed_condition = cond;
+                                        i->failed_condition_trigger = trigger;
+                                        i->failed_condition_negate = negate;
+                                        i->failed_condition_param = param;
                                 }
-
-                                dbus_message_iter_next(&sub);
                         }
-                }
+                        if (r < 0 || sd_bus_message_exit_container(m) < 0)
+                                return log_reply_parse_failed();
+                } else goto skip;
 
                 break;
         }
-
-        case DBUS_TYPE_STRUCT: {
-
+        case SD_BUS_TYPE_STRUCT_BEGIN: {
                 if (streq(name, "LoadError")) {
-                        DBusMessageIter sub;
                         const char *n, *message;
-                        int r;
-
-                        dbus_message_iter_recurse(iter, &sub);
-
-                        r = bus_iter_get_basic_and_next(&sub, DBUS_TYPE_STRING, &n, true);
-                        if (r < 0)
-                                return r;
 
-                        r = bus_iter_get_basic_and_next(&sub, DBUS_TYPE_STRING, &message, false);
-                        if (r < 0)
-                                return r;
+                        if (sd_bus_message_read(m, "(ss)", &n, &message) < 0)
+                                return log_reply_parse_failed();
 
                         if (!isempty(message))
                                 i->load_error = message;
-                }
+                } else goto skip;
 
                 break;
         }
+        default: goto skip;
         }
 
         return 0;
+
+skip:
+        if (sd_bus_message_skip(m, contents) < 0)
+                return log_reply_parse_failed();
+
+        return 0;
 }
 
-static int print_property(const char *name, DBusMessageIter *iter) {
+static int print_property(const char *name, sd_bus_message *m, const char *contents) {
+        int r;
+
         assert(name);
-        assert(iter);
+        assert(m);
 
         /* This is a low-level property printer, see
          * print_status_info() for the nicer output */
@@ -3148,37 +2773,45 @@ static int print_property(const char *name, DBusMessageIter *iter) {
         if (arg_properties && !strv_find(arg_properties, 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_UINT32 && streq(name, "Job")) {
+        switch (contents[0]) {
+        case SD_BUS_TYPE_STRUCT_BEGIN: {
+                if (contents[1] == SD_BUS_TYPE_UINT32 && streq(name, "Job")) {
                         uint32_t u;
 
-                        dbus_message_iter_get_basic(&sub, &u);
+                        if (sd_bus_message_enter_container(m, SD_BUS_TYPE_STRUCT, "uo") < 0 ||
+                            sd_bus_message_read_basic(m, SD_BUS_TYPE_UINT32, &u) < 0)
+                                return log_reply_parse_failed();
 
                         if (u)
                                 printf("%s=%u\n", name, (unsigned) u);
                         else if (arg_all)
                                 printf("%s=\n", name);
 
+                        if (sd_bus_message_skip(m, "o") < 0 ||
+                            sd_bus_message_exit_container(m) < 0)
+                                return log_reply_parse_failed();
+
                         return 0;
-                } else if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING && streq(name, "Unit")) {
+                } else if (contents[1] == SD_BUS_TYPE_STRING && streq(name, "Unit")) {
                         const char *s;
 
-                        dbus_message_iter_get_basic(&sub, &s);
+                        if (sd_bus_message_enter_container(m, SD_BUS_TYPE_STRUCT, "so") < 0 ||
+                            sd_bus_message_read_basic(m, SD_BUS_TYPE_STRING, &s) < 0)
+                                return log_reply_parse_failed();
 
                         if (arg_all || s[0])
                                 printf("%s=%s\n", name, s);
 
+                        if (sd_bus_message_skip(m, "o") < 0 ||
+                            sd_bus_message_exit_container(m) < 0)
+                                return log_reply_parse_failed();
+
                         return 0;
-                } else if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING && streq(name, "LoadError")) {
+                } else if (contents[1] == SD_BUS_TYPE_STRING && streq(name, "LoadError")) {
                         const char *a = NULL, *b = NULL;
 
-                        if (bus_iter_get_basic_and_next(&sub, DBUS_TYPE_STRING, &a, true) >= 0)
-                                bus_iter_get_basic_and_next(&sub, DBUS_TYPE_STRING, &b, false);
+                        if (sd_bus_message_read(m, "(ss)", &a, &b) < 0)
+                                return log_reply_parse_failed();
 
                         if (arg_all || !isempty(a) || !isempty(b))
                                 printf("%s=%s \"%s\"\n", name, strempty(a), strempty(b));
@@ -3188,262 +2821,211 @@ static int print_property(const char *name, DBusMessageIter *iter) {
 
                 break;
         }
+        case SD_BUS_TYPE_ARRAY: {
+                if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "EnvironmentFiles")) {
+                        const char *path;
+                        bool ignore;
 
-        case DBUS_TYPE_ARRAY:
-
-                if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "EnvironmentFiles")) {
-                        DBusMessageIter sub, sub2;
-
-                        dbus_message_iter_recurse(iter, &sub);
-                        while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
-                                const char *path;
-                                dbus_bool_t ignore;
+                        if (sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sb)") < 0)
+                                return log_reply_parse_failed();
 
-                                dbus_message_iter_recurse(&sub, &sub2);
-
-                                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, true) >= 0 &&
-                                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_BOOLEAN, &ignore, false) >= 0)
-                                        printf("EnvironmentFile=%s (ignore_errors=%s)\n", path, yes_no(ignore));
-
-                                dbus_message_iter_next(&sub);
-                        }
+                        while ((r = sd_bus_message_read(m, "(sb)", &path, &ignore)) > 0)
+                                printf("EnvironmentFile=%s (ignore_errors=%s)\n", path, yes_no(ignore));
+                        if (r < 0 || sd_bus_message_exit_container(m) < 0)
+                                return log_reply_parse_failed();
 
                         return 0;
+                } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Paths")) {
+                        const char *type, *path;
 
-                } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Paths")) {
-                        DBusMessageIter sub, sub2;
-
-                        dbus_message_iter_recurse(iter, &sub);
-
-                        while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
-                                const char *type, *path;
-
-                                dbus_message_iter_recurse(&sub, &sub2);
-
-                                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &type, true) >= 0 &&
-                                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, false) >= 0)
-                                        printf("%s=%s\n", type, path);
-
-                                dbus_message_iter_next(&sub);
-                        }
-
-                        return 0;
-
-                } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Listen")) {
-                        DBusMessageIter sub, sub2;
-
-                        dbus_message_iter_recurse(iter, &sub);
-                        while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
-                                const char *type, *path;
-
-                                dbus_message_iter_recurse(&sub, &sub2);
-
-                                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &type, true) >= 0 &&
-                                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, false) >= 0)
-                                        printf("Listen%s=%s\n", type, path);
-
-                                dbus_message_iter_next(&sub);
-                        }
-
-                        return 0;
-
-                } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Timers")) {
-                        DBusMessageIter sub, sub2;
-
-                        dbus_message_iter_recurse(iter, &sub);
-                        while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
-                                const char *base;
-                                uint64_t value, next_elapse;
-
-                                dbus_message_iter_recurse(&sub, &sub2);
-
-                                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &base, true) >= 0 &&
-                                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &value, true) >= 0 &&
-                                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &next_elapse, false) >= 0) {
-                                        char timespan1[FORMAT_TIMESPAN_MAX], timespan2[FORMAT_TIMESPAN_MAX];
-
-                                        printf("%s={ value=%s ; next_elapse=%s }\n",
-                                               base,
-                                               format_timespan(timespan1, sizeof(timespan1), value, 0),
-                                               format_timespan(timespan2, sizeof(timespan2), next_elapse, 0));
-                                }
-
-                                dbus_message_iter_next(&sub);
-                        }
-
-                        return 0;
-
-                } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && startswith(name, "Exec")) {
-                        DBusMessageIter sub;
-
-                        dbus_message_iter_recurse(iter, &sub);
-                        while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
-                                ExecStatusInfo info = {};
-
-                                if (exec_status_info_deserialize(&sub, &info) >= 0) {
-                                        char timestamp1[FORMAT_TIMESTAMP_MAX], timestamp2[FORMAT_TIMESTAMP_MAX];
-                                        _cleanup_free_ char *t;
-
-                                        t = strv_join(info.argv, " ");
-
-                                        printf("%s={ path=%s ; argv[]=%s ; ignore_errors=%s ; start_time=[%s] ; stop_time=[%s] ; pid=%u ; code=%s ; status=%i%s%s }\n",
-                                               name,
-                                               strna(info.path),
-                                               strna(t),
-                                               yes_no(info.ignore),
-                                               strna(format_timestamp(timestamp1, sizeof(timestamp1), info.start_timestamp)),
-                                               strna(format_timestamp(timestamp2, sizeof(timestamp2), info.exit_timestamp)),
-                                               (unsigned) info. pid,
-                                               sigchld_code_to_string(info.code),
-                                               info.status,
-                                               info.code == CLD_EXITED ? "" : "/",
-                                               strempty(info.code == CLD_EXITED ? NULL : signal_to_string(info.status)));
-                                }
-
-                                free(info.path);
-                                strv_free(info.argv);
-
-                                dbus_message_iter_next(&sub);
-                        }
-
-                        return 0;
+                        if (sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ss)") < 0)
+                                return log_reply_parse_failed();
 
-                } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "DeviceAllow")) {
-                        DBusMessageIter sub, sub2;
+                        while ((r = sd_bus_message_read(m, "(ss)", &type, &path)) > 0)
+                                printf("%s=%s\n", type, path);
+                        if (r < 0 || sd_bus_message_exit_container(m) < 0)
+                                return log_reply_parse_failed();
 
-                        dbus_message_iter_recurse(iter, &sub);
-                        while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
-                                const char *path, *rwm;
+                        return 0;
+                } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Listen")) {
+                        const char *type, *path;
 
-                                dbus_message_iter_recurse(&sub, &sub2);
+                        if (sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ss)") < 0)
+                                return log_reply_parse_failed();
 
-                                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, true) >= 0 &&
-                                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &rwm, false) >= 0)
-                                        printf("%s=%s %s\n", name, strna(path), strna(rwm));
+                        while ((r = sd_bus_message_read(m, "(ss)", &type, &path)) > 0)
+                                printf("Listen%s=%s\n", type, path);
+                        if (r < 0 || sd_bus_message_exit_container(m) < 0)
+                                return log_reply_parse_failed();
 
-                                dbus_message_iter_next(&sub);
+                        return 0;
+                } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Timers")) {
+                        const char *base;
+                        uint64_t value, next_elapse;
+
+                        if (sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(stt)") < 0)
+                                return log_reply_parse_failed();
+
+                        while ((r = sd_bus_message_read(m, "(stt)", &base, &value, &next_elapse)) > 0) {
+                                char timespan1[FORMAT_TIMESPAN_MAX], timespan2[FORMAT_TIMESPAN_MAX];
+                                printf("%s={ value=%s ; next_elapse=%s }\n",
+                                       base,
+                                       format_timespan(timespan1, sizeof(timespan1), value, 0),
+                                       format_timespan(timespan2, sizeof(timespan2), next_elapse, 0));
                         }
+                        if (r < 0 || sd_bus_message_exit_container(m) < 0)
+                                return log_reply_parse_failed();
+
                         return 0;
+                } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && startswith(name, "Exec")) {
+                        ExecStatusInfo info = {};
+
+                        if (sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sasbttttuii)") < 0)
+                                return log_reply_parse_failed();
+
+                        while ((r = exec_status_info_deserialize(m, &info)) > 0) {
+                                char timestamp1[FORMAT_TIMESTAMP_MAX], timestamp2[FORMAT_TIMESTAMP_MAX];
+                                _cleanup_free_ char *tt;
+
+                                tt = strv_join(info.argv, " ");
+
+                                printf("%s={ path=%s ; argv[]=%s ; ignore_errors=%s ; start_time=[%s] ; stop_time=[%s] ; pid=%u ; code=%s ; status=%i%s%s }\n",
+                                       name,
+                                       strna(info.path),
+                                       strna(tt),
+                                       yes_no(info.ignore),
+                                       strna(format_timestamp(timestamp1, sizeof(timestamp1), info.start_timestamp)),
+                                       strna(format_timestamp(timestamp2, sizeof(timestamp2), info.exit_timestamp)),
+                                       (unsigned) info. pid,
+                                       sigchld_code_to_string(info.code),
+                                       info.status,
+                                       info.code == CLD_EXITED ? "" : "/",
+                                       strempty(info.code == CLD_EXITED ? NULL : signal_to_string(info.status)));
 
-                } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "BlockIODeviceWeight")) {
-                        DBusMessageIter sub, sub2;
+                                free(info.path);
+                                strv_free(info.argv);
+                                zero(info);
+                        }
+                        if (r < 0 || sd_bus_message_exit_container(m) < 0)
+                                return log_reply_parse_failed();
 
-                        dbus_message_iter_recurse(iter, &sub);
-                        while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
-                                const char *path;
-                                uint64_t weight;
+                        return 0;
+                } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "DeviceAllow")) {
+                        const char *path, *rwm;
 
-                                dbus_message_iter_recurse(&sub, &sub2);
+                        if (sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ss)") < 0)
+                                return log_reply_parse_failed();
 
-                                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, true) >= 0 &&
-                                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &weight, false) >= 0)
-                                        printf("%s=%s %" PRIu64 "\n", name, strna(path), weight);
+                        while ((r = sd_bus_message_read(m, "(ss)", &path, &rwm)) > 0)
+                                printf("%s=%s %s\n", name, strna(path), strna(rwm));
+                        if (r < 0 || sd_bus_message_exit_container(m) < 0)
+                                return log_reply_parse_failed();
 
-                                dbus_message_iter_next(&sub);
-                        }
                         return 0;
+                } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "BlockIODeviceWeight")) {
+                        const char *path;
+                        uint64_t weight;
+
+                        if (sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(st)") < 0)
+                                return log_reply_parse_failed();
 
-                } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && (streq(name, "BlockIOReadBandwidth") || streq(name, "BlockIOWriteBandwidth"))) {
-                        DBusMessageIter sub, sub2;
+                        while ((r = sd_bus_message_read(m, "(st)", &path, &weight)) > 0)
+                                printf("%s=%s %" PRIu64 "\n", name, strna(path), weight);
+                        if (r < 0 || sd_bus_message_exit_container(m) < 0)
+                                return log_reply_parse_failed();
 
-                        dbus_message_iter_recurse(iter, &sub);
-                        while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
-                                const char *path;
-                                uint64_t bandwidth;
+                        return 0;
+                } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && (streq(name, "BlockIOReadBandwidth") || streq(name, "BlockIOWriteBandwidth"))) {
+                        const char *path;
+                        uint64_t bandwidth;
 
-                                dbus_message_iter_recurse(&sub, &sub2);
+                        if (sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(st)") < 0)
+                                return log_reply_parse_failed();
 
-                                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, true) >= 0 &&
-                                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &bandwidth, false) >= 0)
-                                        printf("%s=%s %" PRIu64 "\n", name, strna(path), bandwidth);
+                        while ((r = sd_bus_message_read(m, "(st)", &path, &bandwidth)) > 0)
+                                printf("%s=%s %" PRIu64 "\n", name, strna(path), bandwidth);
+                        if (r < 0 || sd_bus_message_exit_container(m) < 0)
+                                return log_reply_parse_failed();
 
-                                dbus_message_iter_next(&sub);
-                        }
                         return 0;
                 }
 
-
                 break;
         }
+        }
 
-        if (generic_print_property(name, iter, arg_all) > 0)
-                return 0;
+        r = bus_print_property(name, m, arg_all);
+        if (r < 0)
+                return log_reply_parse_failed();
 
-        if (arg_all)
-                printf("%s=[unprintable]\n", name);
+        if (r == 0) {
+                if (sd_bus_message_skip(m, contents) < 0)
+                        return log_reply_parse_failed();
+
+                if (arg_all)
+                        printf("%s=[unprintable]\n", name);
+        }
 
         return 0;
 }
 
 static int show_one(const char *verb,
-                    DBusConnection *bus,
+                    sd_bus *bus,
                     const char *path,
                     bool show_properties,
                     bool *new_line,
                     bool *ellipsized) {
-        _cleanup_free_ DBusMessage *reply = NULL;
-        const char *interface = "";
-        int r;
-        DBusMessageIter iter, sub, sub2, sub3;
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         UnitStatusInfo info = {};
         ExecStatusInfo *p;
+        int r;
 
         assert(path);
         assert(new_line);
 
-        r = bus_method_call_with_reply(
+        r = sd_bus_call_method(
                         bus,
                         "org.freedesktop.systemd1",
                         path,
                         "org.freedesktop.DBus.Properties",
                         "GetAll",
+                        &error,
                         &reply,
-                        NULL,
-                        DBUS_TYPE_STRING, &interface,
-                        DBUS_TYPE_INVALID);
+                        "s", "");
         if (r < 0)
-                return r;
+                return log_method_call_failed("get properties", &error, -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_DICT_ENTRY)  {
-                log_error("Failed to parse reply.");
-                return -EIO;
-        }
-
-        dbus_message_iter_recurse(&iter, &sub);
+        if (sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "{sv}") < 0)
+                return log_reply_parse_failed();
 
         if (*new_line)
                 printf("\n");
 
         *new_line = true;
 
-        while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
-                const char *name;
-
-                assert(dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_DICT_ENTRY);
-                dbus_message_iter_recurse(&sub, &sub2);
-
-                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &name, true) < 0 ||
-                    dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_VARIANT) {
-                        log_error("Failed to parse reply.");
-                        return -EIO;
-                }
+        while (!sd_bus_message_at_end(reply, false)) {
+                const char *name, *contents;
 
-                dbus_message_iter_recurse(&sub2, &sub3);
+                if (sd_bus_message_enter_container(reply, SD_BUS_TYPE_DICT_ENTRY, "sv") < 0 ||
+                    sd_bus_message_read_basic(reply, SD_BUS_TYPE_STRING, &name) < 0 ||
+                    sd_bus_message_peek_type(reply, NULL, &contents) < 0 ||
+                    sd_bus_message_enter_container(reply, SD_BUS_TYPE_VARIANT, contents) < 0)
+                        return log_reply_parse_failed();
 
                 if (show_properties)
-                        r = print_property(name, &sub3);
+                        r = print_property(name, reply, contents);
                 else
-                        r = status_property(name, &sub3, &info);
-                if (r < 0) {
-                        log_error("Failed to parse reply.");
-                        return -EIO;
-                }
-
-                dbus_message_iter_next(&sub);
+                        r = status_property(name, reply, &info, contents);
+                if (r < 0 ||
+                    sd_bus_message_exit_container(reply) < 0 ||
+                    sd_bus_message_exit_container(reply) < 0)
+                        return log_reply_parse_failed();
         }
 
+        if (sd_bus_message_exit_container(reply) < 0)
+                return log_reply_parse_failed();
+
         r = 0;
 
         if (!show_properties) {
@@ -3482,47 +3064,40 @@ static int show_one(const char *verb,
 }
 
 static int show_one_by_pid(const char *verb,
-                           DBusConnection *bus,
+                           sd_bus *bus,
                            uint32_t pid,
                            bool *new_line,
                            bool *ellipsized) {
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         const char *path = NULL;
-        _cleanup_dbus_error_free_ DBusError error;
         int r;
 
-        dbus_error_init(&error);
-
-        r = bus_method_call_with_reply(
+        r = sd_bus_call_method(
                         bus,
                         "org.freedesktop.systemd1",
                         "/org/freedesktop/systemd1",
                         "org.freedesktop.systemd1.Manager",
                         "GetUnitByPID",
+                        &error,
                         &reply,
-                        NULL,
-                        DBUS_TYPE_UINT32, &pid,
-                        DBUS_TYPE_INVALID);
+                        "u", pid);
         if (r < 0)
-                return r;
+                return log_method_call_failed("get unit by pid", &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));
-                return -EIO;
-        }
+        if (sd_bus_message_read_basic(reply, SD_BUS_TYPE_OBJECT_PATH, &path) < 0)
+                return log_reply_parse_failed();
 
-        r = show_one(verb, bus, path, false, new_line, ellipsized);
-        return r;
+        return show_one(verb, bus, path, false, new_line, ellipsized);
 }
 
 static int show_all(const char* verb,
-                    DBusConnection *bus,
+                    sd_bus *bus,
                     bool show_properties,
                     bool *new_line,
                     bool *ellipsized) {
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         _cleanup_free_ struct unit_info *unit_infos = NULL;
         unsigned c = 0;
         const struct unit_info *u;
@@ -3554,7 +3129,7 @@ static int show_all(const char* verb,
         return 0;
 }
 
-static int show(DBusConnection *bus, char **args) {
+static int show(sd_bus *bus, char **args) {
         int r, ret = 0;
         bool show_properties, show_status, new_line = false;
         char **name;
@@ -3621,13 +3196,12 @@ static int show(DBusConnection *bus, char **args) {
         return ret;
 }
 
-static int append_assignment(DBusMessageIter *iter, const char *assignment) {
+static int append_assignment(sd_bus_message *m, const char *assignment) {
         const char *eq;
         char *field;
-        DBusMessageIter sub;
         int r;
 
-        assert(iter);
+        assert(m);
         assert(assignment);
 
         eq = strchr(assignment, '=');
@@ -3639,14 +3213,14 @@ static int append_assignment(DBusMessageIter *iter, const char *assignment) {
         field = strndupa(assignment, eq - assignment);
         eq ++;
 
-        if (!dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &field))
-                return log_oom();
+        r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, field);
+        if (r < 0)
+                return r;
 
         if (streq(field, "CPUAccounting") ||
             streq(field, "MemoryAccounting") ||
             streq(field, "BlockIOAccounting")) {
-                dbus_bool_t b;
-
+                bool b;
                 r = parse_boolean(eq);
                 if (r < 0) {
                         log_error("Failed to parse boolean assignment %s.", assignment);
@@ -3654,10 +3228,11 @@ static int append_assignment(DBusMessageIter *iter, const char *assignment) {
                 }
 
                 b = r;
-                if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, "b", &sub) ||
-                    !dbus_message_iter_append_basic(&sub, DBUS_TYPE_BOOLEAN, &b))
-                        return log_oom();
+                r = sd_bus_message_open_container(m, SD_BUS_TYPE_VARIANT, "b");
+                if (r < 0)
+                        return r;
 
+                r = sd_bus_message_append_basic(m, SD_BUS_TYPE_BOOLEAN, &b);
         } else if (streq(field, "MemoryLimit")) {
                 off_t bytes;
                 uint64_t u;
@@ -3669,10 +3244,11 @@ static int append_assignment(DBusMessageIter *iter, const char *assignment) {
                 }
 
                 u = bytes;
-                if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, "t", &sub) ||
-                    !dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT64, &u))
-                        return log_oom();
+                r = sd_bus_message_open_container(m, SD_BUS_TYPE_VARIANT, "t");
+                if (r < 0)
+                        return r;
 
+                r = sd_bus_message_append_basic(m, SD_BUS_TYPE_UINT64, &u);
         } else if (streq(field, "CPUShares") || streq(field, "BlockIOWeight")) {
                 uint64_t u;
 
@@ -3682,26 +3258,28 @@ static int append_assignment(DBusMessageIter *iter, const char *assignment) {
                         return -EINVAL;
                 }
 
-                if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, "t", &sub) ||
-                    !dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT64, &u))
-                        return log_oom();
+                r = sd_bus_message_open_container(m, SD_BUS_TYPE_VARIANT, "t");
+                if (r < 0)
+                        return r;
 
+                r = sd_bus_message_append_basic(m, SD_BUS_TYPE_UINT64, &u);
         } else if (streq(field, "DevicePolicy")) {
+                r = sd_bus_message_open_container(m, SD_BUS_TYPE_VARIANT, "s");
+                if (r < 0)
+                        return r;
 
-                if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, "s", &sub) ||
-                    !dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &eq))
-                        return log_oom();
-
+                r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, eq);
         } else if (streq(field, "DeviceAllow")) {
-                DBusMessageIter sub2;
+                r = sd_bus_message_open_container(m, SD_BUS_TYPE_VARIANT, "a(ss)");
+                if (r < 0)
+                        return r;
 
-                if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, "a(ss)", &sub) ||
-                    !dbus_message_iter_open_container(&sub, DBUS_TYPE_ARRAY, "(ss)", &sub2))
-                        return log_oom();
+                r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, "(ss)");
+                if (r < 0)
+                        return r;
 
                 if (!isempty(eq)) {
                         const char *path, *rwm;
-                        DBusMessageIter sub3;
                         char *e;
 
                         e = strchr(eq, ' ');
@@ -3718,26 +3296,23 @@ static int append_assignment(DBusMessageIter *iter, const char *assignment) {
                                 return -EINVAL;
                         }
 
-                        if (!dbus_message_iter_open_container(&sub2, DBUS_TYPE_STRUCT, NULL, &sub3) ||
-                            !dbus_message_iter_append_basic(&sub3, DBUS_TYPE_STRING, &path) ||
-                            !dbus_message_iter_append_basic(&sub3, DBUS_TYPE_STRING, &rwm) ||
-                            !dbus_message_iter_close_container(&sub2, &sub3))
-                                return log_oom();
+                        r = sd_bus_message_append(m, "(ss)", path, rwm);
+                        if (r < 0)
+                                return r;
                 }
 
-                if (!dbus_message_iter_close_container(&sub, &sub2))
-                        return log_oom();
-
+                r = sd_bus_message_close_container(m);
         } else if (streq(field, "BlockIOReadBandwidth") || streq(field, "BlockIOWriteBandwidth")) {
-                DBusMessageIter sub2;
+                r = sd_bus_message_open_container(m, SD_BUS_TYPE_VARIANT, "a(st)");
+                if (r < 0)
+                        return r;
 
-                if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, "a(st)", &sub) ||
-                    !dbus_message_iter_open_container(&sub, DBUS_TYPE_ARRAY, "(st)", &sub2))
-                        return log_oom();
+                r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, "(st)");
+                if (r < 0)
+                        return r;
 
                 if (!isempty(eq)) {
                         const char *path, *bandwidth;
-                        DBusMessageIter sub3;
                         uint64_t u;
                         off_t bytes;
                         char *e;
@@ -3763,27 +3338,23 @@ static int append_assignment(DBusMessageIter *iter, const char *assignment) {
                         }
 
                         u = (uint64_t) bytes;
-
-                        if (!dbus_message_iter_open_container(&sub2, DBUS_TYPE_STRUCT, NULL, &sub3) ||
-                            !dbus_message_iter_append_basic(&sub3, DBUS_TYPE_STRING, &path) ||
-                            !dbus_message_iter_append_basic(&sub3, DBUS_TYPE_UINT64, &u) ||
-                            !dbus_message_iter_close_container(&sub2, &sub3))
-                                return log_oom();
+                        r = sd_bus_message_append(m, "(st)", path, u);
+                        if (r < 0)
+                                return r;
                 }
 
-                if (!dbus_message_iter_close_container(&sub, &sub2))
-                        return log_oom();
-
+                r = sd_bus_message_close_container(m);
         } else if (streq(field, "BlockIODeviceWeight")) {
-                DBusMessageIter sub2;
+                r = sd_bus_message_open_container(m, SD_BUS_TYPE_VARIANT, "a(st)");
+                if (r < 0)
+                        return r;
 
-                if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, "a(st)", &sub) ||
-                    !dbus_message_iter_open_container(&sub, DBUS_TYPE_ARRAY, "(st)", &sub2))
-                        return log_oom();
+                r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, "(st)");
+                if (r < 0)
+                        return r;
 
                 if (!isempty(eq)) {
                         const char *path, *weight;
-                        DBusMessageIter sub3;
                         uint64_t u;
                         char *e;
 
@@ -3806,101 +3377,86 @@ static int append_assignment(DBusMessageIter *iter, const char *assignment) {
                                 log_error("Failed to parse %s value %s.", field, weight);
                                 return -EINVAL;
                         }
-                        if (!dbus_message_iter_open_container(&sub2, DBUS_TYPE_STRUCT, NULL, &sub3) ||
-                            !dbus_message_iter_append_basic(&sub3, DBUS_TYPE_STRING, &path) ||
-                            !dbus_message_iter_append_basic(&sub3, DBUS_TYPE_UINT64, &u) ||
-                            !dbus_message_iter_close_container(&sub2, &sub3))
-                                return log_oom();
+                        r = sd_bus_message_append(m, "(st)", path, u);
+                        if (r < 0)
+                                return r;
                 }
 
-                if (!dbus_message_iter_close_container(&sub, &sub2))
-                        return log_oom();
-
+                r = sd_bus_message_close_container(m);
         } else {
                 log_error("Unknown assignment %s.", assignment);
                 return -EINVAL;
         }
+        if (r < 0)
+                return r;
 
-        if (!dbus_message_iter_close_container(iter, &sub))
-                return log_oom();
+        r = sd_bus_message_close_container(m);
+        if (r < 0)
+                return r;
 
         return 0;
 }
 
-static int set_property(DBusConnection *bus, char **args) {
-
-        _cleanup_dbus_message_unref_ DBusMessage *m = NULL, *reply = NULL;
+static int set_property(sd_bus *bus, char **args) {
+        _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         _cleanup_free_ char *n = NULL;
-        DBusMessageIter iter, sub;
-        dbus_bool_t runtime;
-        DBusError error;
         char **i;
         int r;
 
-        dbus_error_init(&error);
-
-        m = dbus_message_new_method_call(
+        r = sd_bus_message_new_method_call(
+                        bus,
                         "org.freedesktop.systemd1",
                         "/org/freedesktop/systemd1",
                         "org.freedesktop.systemd1.Manager",
-                        "SetUnitProperties");
-        if (!m)
-                return log_oom();
-
-        dbus_message_iter_init_append(m, &iter);
-
-        runtime = arg_runtime;
+                        "SetUnitProperties",
+                        &m);
+        if (r < 0)
+                return log_message_creation_failed(-r);
 
         n = unit_name_mangle(args[1]);
         if (!n)
                 return log_oom();
 
-        if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &n) ||
-            !dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &runtime) ||
-            !dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(sv)", &sub))
-                return log_oom();
-
-        STRV_FOREACH(i, args + 2) {
-                DBusMessageIter sub2;
+        r = sd_bus_message_append(m, "sb", n, arg_runtime);
+        if (r < 0)
+                return log_message_creation_failed(-r);
 
-                if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
-                        return log_oom();
+        r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, "(sv)");
+        if (r < 0)
+                return log_message_creation_failed(-r);
 
-                r = append_assignment(&sub2, *i);
+        STRV_FOREACH(i, args + 2) {
+                r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
                 if (r < 0)
-                        return r;
+                        return log_message_creation_failed(-r);
 
-                if (!dbus_message_iter_close_container(&sub, &sub2))
-                        return log_oom();
+                r = append_assignment(m, *i);
+                if (r < 0)
+                        return log_message_creation_failed(-r);
 
+                r = sd_bus_message_close_container(m);
+                if (r < 0)
+                        return log_message_creation_failed(-r);
         }
 
-        if (!dbus_message_iter_close_container(&iter, &sub))
-                return log_oom();
+        r = sd_bus_message_close_container(m);
+        if (r < 0)
+                return log_message_creation_failed(-r);
 
-        reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
-        if (!reply) {
-                log_error("Failed to issue method call: %s", bus_error_message(&error));
-                dbus_error_free(&error);
-                return -EIO;
-        }
+        r = sd_bus_send_with_reply_and_block(bus, m, -1, &error, NULL);
+        if (r < 0)
+                return log_method_call_failed("set unit properties", &error, -r);
 
         return 0;
 }
 
-static int snapshot(DBusConnection *bus, char **args) {
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
-        DBusError error;
-        int r;
-        dbus_bool_t cleanup = FALSE;
-        DBusMessageIter iter, sub;
-        const char
-                *path, *id,
-                *interface = "org.freedesktop.systemd1.Unit",
-                *property = "Id";
+static int snapshot(sd_bus *bus, char **args) {
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         _cleanup_free_ char *n = NULL;
-
-        dbus_error_init(&error);
+        const char *path, *id;
+        int r;
 
         if (strv_length(args) > 1)
                 n = unit_name_mangle_with_suffix(args[1], ".snapshot");
@@ -3909,59 +3465,31 @@ static int snapshot(DBusConnection *bus, char **args) {
         if (!n)
                 return log_oom();
 
-        r = bus_method_call_with_reply(
+        r = sd_bus_call_method(
                         bus,
                         "org.freedesktop.systemd1",
                         "/org/freedesktop/systemd1",
                         "org.freedesktop.systemd1.Manager",
                         "CreateSnapshot",
+                        &error,
                         &reply,
-                        NULL,
-                        DBUS_TYPE_STRING, &n,
-                        DBUS_TYPE_BOOLEAN, &cleanup,
-                        DBUS_TYPE_INVALID);
+                        "sb", n, false);
         if (r < 0)
-                return 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));
-                dbus_error_free(&error);
-                return -EIO;
-        }
+                return log_method_call_failed("create snapshot", &error, -r);
 
-        dbus_message_unref(reply);
-        reply = NULL;
+        if (sd_bus_message_read_basic(reply, SD_BUS_TYPE_OBJECT_PATH, &path) < 0)
+                return log_reply_parse_failed();
 
-        r = bus_method_call_with_reply (
+        r = sd_bus_get_property_basic(
                         bus,
                         "org.freedesktop.systemd1",
                         path,
-                        "org.freedesktop.DBus.Properties",
-                        "Get",
-                        &reply,
-                        NULL,
-                        DBUS_TYPE_STRING, &interface,
-                        DBUS_TYPE_STRING, &property,
-                        DBUS_TYPE_INVALID);
+                        "org.freedesktop.systemd1.Unit",
+                        "Id",
+                        &error,
+                        SD_BUS_TYPE_STRING, &id);
         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 -EIO;
-        }
-
-        dbus_message_iter_recurse(&iter, &sub);
-
-        if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING)  {
-                log_error("Failed to parse reply.");
-                return -EIO;
-        }
-
-        dbus_message_iter_get_basic(&sub, &id);
+                return log_method_call_failed("get property", &error, -r);
 
         if (!arg_quiet)
                 puts(id);
@@ -3969,40 +3497,40 @@ static int snapshot(DBusConnection *bus, char **args) {
         return 0;
 }
 
-static int delete_snapshot(DBusConnection *bus, char **args) {
+static int delete_snapshot(sd_bus *bus, char **args) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         char **name;
+        int r;
 
         assert(args);
 
         STRV_FOREACH(name, args+1) {
                 _cleanup_free_ char *n = NULL;
-                int r;
 
                 n = unit_name_mangle_with_suffix(*name, ".snapshot");
                 if (!n)
                         return log_oom();
 
-                r = bus_method_call_with_reply(
+                r = sd_bus_call_method(
                                 bus,
                                 "org.freedesktop.systemd1",
                                 "/org/freedesktop/systemd1",
                                 "org.freedesktop.systemd1.Manager",
                                 "RemoveSnapshot",
+                                &error,
                                 NULL,
-                                NULL,
-                                DBUS_TYPE_STRING, &n,
-                                DBUS_TYPE_INVALID);
+                                "s", n);
                 if (r < 0)
-                        return r;
+                        return log_method_call_failed("remove snapshot", &error, -r);
         }
 
         return 0;
 }
 
-static int daemon_reload(DBusConnection *bus, char **args) {
-        int r;
+static int daemon_reload(sd_bus *bus, char **args) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         const char *method;
-        DBusError error;
+        int r;
 
         if (arg_action == ACTION_RELOAD)
                 method = "Reload";
@@ -4024,15 +3552,15 @@ static int daemon_reload(DBusConnection *bus, char **args) {
                                     /* "daemon-reload" */ "Reload";
         }
 
-        r = bus_method_call_with_reply(
+        r = sd_bus_call_method(
                         bus,
                         "org.freedesktop.systemd1",
                         "/org/freedesktop/systemd1",
                         "org.freedesktop.systemd1.Manager",
                         method,
-                        NULL,
                         &error,
-                        DBUS_TYPE_INVALID);
+                        NULL,
+                        NULL);
 
         if (r == -ENOENT && arg_action != ACTION_SYSTEMCTL)
                 /* There's always a fallback possible for
@@ -4043,15 +3571,15 @@ static int daemon_reload(DBusConnection *bus, char **args) {
                  * reply */
                 r = 0;
         else if (r < 0)
-                log_error("Failed to issue method call: %s", bus_error_message(&error));
+                log_method_call_failed("issue method call", &error, -r);
 
-        dbus_error_free(&error);
         return r;
 }
 
-static int reset_failed(DBusConnection *bus, char **args) {
-        int r = 0;
+static int reset_failed(sd_bus *bus, char **args) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         char **name;
+        int r;
 
         if (strv_length(args) <= 1)
                 return daemon_reload(bus, args);
@@ -4063,84 +3591,62 @@ static int reset_failed(DBusConnection *bus, char **args) {
                 if (!n)
                         return log_oom();
 
-                r = bus_method_call_with_reply(
+                r = sd_bus_call_method(
                                 bus,
                                 "org.freedesktop.systemd1",
                                 "/org/freedesktop/systemd1",
                                 "org.freedesktop.systemd1.Manager",
                                 "ResetFailedUnit",
+                                &error,
                                 NULL,
-                                NULL,
-                                DBUS_TYPE_STRING, &n,
-                                DBUS_TYPE_INVALID);
+                                "s", n);
                 if (r < 0)
-                        return r;
+                        return log_method_call_failed("reset failed unit", &error, -r);
         }
 
         return 0;
 }
 
-static int show_enviroment(DBusConnection *bus, char **args) {
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
-        DBusMessageIter iter, sub, sub2;
+static int show_environment(sd_bus *bus, char **args) {
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+        const char *text;
         int r;
-        const char
-                *interface = "org.freedesktop.systemd1.Manager",
-                *property = "Environment";
 
         pager_open_if_enabled();
 
-        r = bus_method_call_with_reply(
+        r = sd_bus_get_property(
                         bus,
                         "org.freedesktop.systemd1",
                         "/org/freedesktop/systemd1",
-                        "org.freedesktop.DBus.Properties",
-                        "Get",
+                        "org.freedesktop.systemd1.Manager",
+                        "Environment",
+                        &error,
                         &reply,
-                        NULL,
-                        DBUS_TYPE_STRING, &interface,
-                        DBUS_TYPE_STRING, &property,
-                        DBUS_TYPE_INVALID);
+                        "as");
         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 -EIO;
-        }
-
-        dbus_message_iter_recurse(&iter, &sub);
-
-        if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_ARRAY ||
-            dbus_message_iter_get_element_type(&sub) != DBUS_TYPE_STRING)  {
-                log_error("Failed to parse reply.");
-                return -EIO;
-        }
-
-        dbus_message_iter_recurse(&sub, &sub2);
-
-        while (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_INVALID) {
-                const char *text;
+                return log_method_call_failed("get environment", &error, -r);
 
-                if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_STRING) {
-                        log_error("Failed to parse reply.");
-                        return -EIO;
-                }
+        if (sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "s") < 0)
+                return log_reply_parse_failed();
 
-                dbus_message_iter_get_basic(&sub2, &text);
+        while ((r = sd_bus_message_read_basic(reply, SD_BUS_TYPE_STRING, &text)) > 0)
                 puts(text);
+        if (r < 0)
+                return log_reply_parse_failed();
 
-                dbus_message_iter_next(&sub2);
-        }
+        if (sd_bus_message_exit_container(reply) < 0)
+                return log_reply_parse_failed();
 
         return 0;
 }
 
-static int switch_root(DBusConnection *bus, char **args) {
+static int switch_root(sd_bus *bus, char **args) {
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         unsigned l;
         const char *root;
         _cleanup_free_ char *init = NULL;
+        int r;
 
         l = strv_length(args);
         if (l < 2 || l > 3) {
@@ -4165,55 +3671,51 @@ static int switch_root(DBusConnection *bus, char **args) {
 
         log_debug("switching root - root: %s; init: %s", root, init);
 
-        return bus_method_call_with_reply(
+        r = sd_bus_call_method(
                         bus,
                         "org.freedesktop.systemd1",
                         "/org/freedesktop/systemd1",
                         "org.freedesktop.systemd1.Manager",
                         "SwitchRoot",
+                        &error,
                         NULL,
-                        NULL,
-                        DBUS_TYPE_STRING, &root,
-                        DBUS_TYPE_STRING, &init,
-                        DBUS_TYPE_INVALID);
+                        "ss", root, init);
+        if (r < 0)
+                return log_method_call_failed("switch root", &error, -r);
+
+        return 0;
 }
 
-static int set_environment(DBusConnection *bus, char **args) {
-        _cleanup_dbus_message_unref_ DBusMessage *m = NULL, *reply = NULL;
-        DBusError error;
+static int set_environment(sd_bus *bus, char **args) {
+        _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         const char *method;
-        DBusMessageIter iter;
         int r;
 
         assert(bus);
         assert(args);
 
-        dbus_error_init(&error);
-
         method = streq(args[0], "set-environment")
                 ? "SetEnvironment"
                 : "UnsetEnvironment";
 
-        m = dbus_message_new_method_call(
+        r = sd_bus_message_new_method_call(
+                        bus,
                         "org.freedesktop.systemd1",
                         "/org/freedesktop/systemd1",
                         "org.freedesktop.systemd1.Manager",
-                        method);
-        if (!m)
-                return log_oom();
-
-        dbus_message_iter_init_append(m, &iter);
+                        method,
+                        &m);
+        if (r < 0)
+                return log_message_creation_failed(-r);
 
-        r = bus_append_strv_iter(&iter, args + 1);
+        r = sd_bus_message_append_strv(m, args + 1);
         if (r < 0)
-                return log_oom();
+                return log_message_creation_failed(-r);
 
-        reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
-        if (!reply) {
-                log_error("Failed to issue method call: %s", bus_error_message(&error));
-                dbus_error_free(&error);
-                return -EIO;
-        }
+        r = sd_bus_send_with_reply_and_block(bus, m, -1, &error, NULL);
+        if (r < 0)
+                return log_method_call_failed("issue method call", &error, -r);
 
         return 0;
 }
@@ -4408,17 +3910,15 @@ static int mangle_names(char **original_names, char ***mangled_names) {
         return 0;
 }
 
-static int enable_unit(DBusConnection *bus, char **args) {
+static int enable_unit(sd_bus *bus, char **args) {
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL, *m = NULL;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+        _cleanup_strv_free_ char **mangled_names = NULL;
         const char *verb = args[0];
         UnitFileChange *changes = NULL;
         unsigned n_changes = 0, i;
         int carries_install_info = -1;
-        _cleanup_dbus_message_unref_ DBusMessage *m = NULL, *reply = NULL;
         int r;
-        _cleanup_dbus_error_free_ DBusError error;
-        _cleanup_strv_free_ char **mangled_names = NULL;
-
-        dbus_error_init(&error);
 
         if (!args[1])
                 return 0;
@@ -4470,10 +3970,8 @@ static int enable_unit(DBusConnection *bus, char **args) {
 
                 r = 0;
         } else {
-                const char *method;
+                const char *method, *type, *path, *source;
                 bool send_force = true, expect_carries_install_info = false;
-                dbus_bool_t a, b;
-                DBusMessageIter iter, sub, sub2;
 
                 if (streq(verb, "enable")) {
                         method = "EnableUnitFiles";
@@ -4499,103 +3997,58 @@ static int enable_unit(DBusConnection *bus, char **args) {
                 } else
                         assert_not_reached("Unknown verb");
 
-                m = dbus_message_new_method_call(
+                r = sd_bus_message_new_method_call(
+                                bus,
                                 "org.freedesktop.systemd1",
                                 "/org/freedesktop/systemd1",
                                 "org.freedesktop.systemd1.Manager",
-                                method);
-                if (!m) {
-                        r = log_oom();
-                        goto finish;
-                }
-
-                dbus_message_iter_init_append(m, &iter);
+                                method,
+                                &m);
+                if (r < 0)
+                        return log_message_creation_failed(-r);
 
-                r = bus_append_strv_iter(&iter, mangled_names);
-                if (r < 0) {
-                        log_error("Failed to append unit files.");
-                        goto finish;
-                }
+                r = sd_bus_message_append_strv(m, mangled_names);
+                if (r < 0)
+                        return log_message_creation_failed(-r);
 
-                a = arg_runtime;
-                if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &a)) {
-                        log_error("Failed to append runtime boolean.");
-                        r = -ENOMEM;
-                        goto finish;
-                }
+                r = sd_bus_message_append_basic(m, SD_BUS_TYPE_BOOLEAN, &arg_runtime);
+                if (r < 0)
+                        return log_message_creation_failed(-r);
 
                 if (send_force) {
-                        b = arg_force;
-
-                        if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &b)) {
-                                log_error("Failed to append force boolean.");
-                                r = -ENOMEM;
-                                goto finish;
-                        }
-                }
-
-                reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
-                if (!reply) {
-                        log_error("Failed to issue method call: %s", bus_error_message(&error));
-                        r = -EIO;
-                        goto finish;
+                        r = sd_bus_message_append_basic(m, SD_BUS_TYPE_BOOLEAN, &arg_force);
+                        if (r < 0)
+                                return log_message_creation_failed(-r);
                 }
 
-                if (!dbus_message_iter_init(reply, &iter)) {
-                        log_error("Failed to initialize iterator.");
-                        goto finish;
-                }
+                r = sd_bus_send_with_reply_and_block(bus, m, -1, &error, &reply);
+                if (r < 0)
+                        return log_method_call_failed("issue method call", &error, -r);
 
                 if (expect_carries_install_info) {
-                        r = bus_iter_get_basic_and_next(&iter, DBUS_TYPE_BOOLEAN, &b, true);
-                        if (r < 0) {
-                                log_error("Failed to parse reply.");
-                                goto finish;
-                        }
-
-                        carries_install_info = b;
-                }
-
-                if (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.");
-                        r = -EIO;
-                        goto finish;
+                        if (sd_bus_message_read_basic(reply, SD_BUS_TYPE_BOOLEAN, &carries_install_info) < 0)
+                                return log_reply_parse_failed();
                 }
 
-                dbus_message_iter_recurse(&iter, &sub);
-                while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
-                        const char *type, *path, *source;
-
-                        if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
-                                log_error("Failed to parse reply.");
-                                r = -EIO;
-                                goto finish;
-                        }
-
-                        dbus_message_iter_recurse(&sub, &sub2);
-
-                        if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &type, true) < 0 ||
-                            bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, true) < 0 ||
-                            bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &source, false) < 0) {
-                                log_error("Failed to parse reply.");
-                                r = -EIO;
-                                goto finish;
-                        }
+                if (sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(sss)") < 0)
+                        return log_reply_parse_failed();
 
+                while ((r = sd_bus_message_read(reply, "(sss)", &type, &path, &source)) > 0) {
                         if (!arg_quiet) {
                                 if (streq(type, "symlink"))
                                         log_info("ln -s '%s' '%s'", source, path);
                                 else
                                         log_info("rm '%s'", path);
                         }
-
-                        dbus_message_iter_next(&sub);
                 }
+                if (r < 0 || sd_bus_message_exit_container(reply) < 0)
+                        return log_reply_parse_failed();
 
                 /* Try to reload if enabeld */
                 if (!arg_no_reload)
                         r = daemon_reload(bus, args);
+                else
+                        r = 0;
         }
 
         if (carries_install_info == 0)
@@ -4615,16 +4068,14 @@ finish:
         return r;
 }
 
-static int unit_is_enabled(DBusConnection *bus, char **args) {
-        _cleanup_dbus_error_free_ DBusError error;
+static int unit_is_enabled(sd_bus *bus, char **args) {
+        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         int r;
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
         bool enabled;
         char **name;
         _cleanup_strv_free_ char **mangled_names = NULL;
 
-        dbus_error_init(&error);
-
         r = mangle_names(args+1, &mangled_names);
         if (r < 0)
                 return r;
@@ -4658,29 +4109,20 @@ static int unit_is_enabled(DBusConnection *bus, char **args) {
                 STRV_FOREACH(name, mangled_names) {
                         const char *s;
 
-                        r = bus_method_call_with_reply (
+                        r = sd_bus_call_method (
                                         bus,
                                         "org.freedesktop.systemd1",
                                         "/org/freedesktop/systemd1",
                                         "org.freedesktop.systemd1.Manager",
                                         "GetUnitFileState",
+                                        &error,
                                         &reply,
-                                        NULL,
-                                        DBUS_TYPE_STRING, name,
-                                        DBUS_TYPE_INVALID);
-
-                        if (r)
-                                return r;
-
-                        if (!dbus_message_get_args(reply, &error,
-                                                   DBUS_TYPE_STRING, &s,
-                                                   DBUS_TYPE_INVALID)) {
-                                log_error("Failed to parse reply: %s", bus_error_message(&error));
-                                return -EIO;
-                        }
+                                        "s", name);
+                        if (r < 0)
+                                return log_method_call_failed("get unit file state", &error, -r);
 
-                        dbus_message_unref(reply);
-                        reply = NULL;
+                        if (sd_bus_message_read(reply, "s", &s) < 0)
+                                return log_reply_parse_failed();
 
                         if (streq(s, "enabled") ||
                             streq(s, "enabled-runtime") ||
@@ -4689,6 +4131,9 @@ static int unit_is_enabled(DBusConnection *bus, char **args) {
 
                         if (!arg_quiet)
                                 puts(s);
+
+                        sd_bus_message_unref(reply);
+                        reply = NULL;
                 }
         }
 
@@ -4724,7 +4169,6 @@ static int systemctl_help(void) {
                "  -s --signal=SIGNAL  Which signal to send\n"
                "  -H --host=[USER@]HOST\n"
                "                      Show information for remote host\n"
-               "  -P --privileged     Acquire privileges before execution\n"
                "  -q --quiet          Suppress output\n"
                "     --no-block       Do not wait until operation finished\n"
                "     --no-wall        Don't send wall message before halt/power-off/reboot\n"
@@ -4955,7 +4399,6 @@ static int systemctl_parse_argv(int argc, char *argv[]) {
                 { "signal",              required_argument, NULL, 's'                     },
                 { "no-ask-password",     no_argument,       NULL, ARG_NO_ASK_PASSWORD     },
                 { "host",                required_argument, NULL, 'H'                     },
-                { "privileged",          no_argument,       NULL, 'P'                     },
                 { "runtime",             no_argument,       NULL, ARG_RUNTIME             },
                 { "lines",               required_argument, NULL, 'n'                     },
                 { "output",              required_argument, NULL, 'o'                     },
@@ -4969,7 +4412,7 @@ static int systemctl_parse_argv(int argc, char *argv[]) {
         assert(argc >= 0);
         assert(argv);
 
-        while ((c = getopt_long(argc, argv, "ht:p:alqfs:H:Pn:o:i", options, NULL)) >= 0) {
+        while ((c = getopt_long(argc, argv, "ht:p:alqfs:H:n:o:i", options, NULL)) >= 0) {
 
                 switch (c) {
 
@@ -5161,12 +4604,8 @@ static int systemctl_parse_argv(int argc, char *argv[]) {
                         arg_ask_password = false;
                         break;
 
-                case 'P':
-                        arg_transport = TRANSPORT_POLKIT;
-                        break;
-
                 case 'H':
-                        arg_transport = TRANSPORT_SSH;
+                        arg_transport = BUS_TRANSPORT_REMOTE;
                         parse_user_at_host(optarg, &arg_user, &arg_host);
                         break;
 
@@ -5224,7 +4663,7 @@ static int systemctl_parse_argv(int argc, char *argv[]) {
                 }
         }
 
-        if (arg_transport != TRANSPORT_NORMAL && arg_scope != UNIT_FILE_SYSTEM) {
+        if (arg_transport != BUS_TRANSPORT_LOCAL && arg_scope != UNIT_FILE_SYSTEM) {
                 log_error("Cannot access user instance remotely.");
                 return -EINVAL;
         }
@@ -5692,7 +5131,7 @@ static int talk_initctl(void) {
         return 1;
 }
 
-static int systemctl_main(DBusConnection *bus, int argc, char *argv[], DBusError *error) {
+static int systemctl_main(sd_bus *bus, int argc, char *argv[], const int r) {
 
         static const struct {
                 const char* verb;
@@ -5702,7 +5141,7 @@ static int systemctl_main(DBusConnection *bus, int argc, char *argv[], DBusError
                         EQUAL
                 } argc_cmp;
                 const int argc;
-                int (* const dispatch)(DBusConnection *bus, char **args);
+                int (* const dispatch)(sd_bus *bus, char **args);
         } verbs[] = {
                 { "list-units",            LESS,  1, list_units        },
                 { "list-unit-files",       EQUAL, 1, list_unit_files   },
@@ -5733,7 +5172,7 @@ static int systemctl_main(DBusConnection *bus, int argc, char *argv[], DBusError
                 { "delete",                MORE,  2, delete_snapshot   },
                 { "daemon-reload",         EQUAL, 1, daemon_reload     },
                 { "daemon-reexec",         EQUAL, 1, daemon_reload     },
-                { "show-environment",      EQUAL, 1, show_enviroment   },
+                { "show-environment",      EQUAL, 1, show_environment  },
                 { "set-environment",       MORE,  2, set_environment   },
                 { "unset-environment",     MORE,  2, set_environment   },
                 { "halt",                  EQUAL, 1, start_special     },
@@ -5768,7 +5207,6 @@ static int systemctl_main(DBusConnection *bus, int argc, char *argv[], DBusError
 
         assert(argc >= 0);
         assert(argv);
-        assert(error);
 
         left = argc - optind;
 
@@ -5844,16 +5282,14 @@ static int systemctl_main(DBusConnection *bus, int argc, char *argv[], DBusError
                 if (((!streq(verbs[i].verb, "reboot") &&
                       !streq(verbs[i].verb, "halt") &&
                       !streq(verbs[i].verb, "poweroff")) || arg_force <= 0) && !bus) {
-                        log_error("Failed to get D-Bus connection: %s",
-                                  dbus_error_is_set(error) ? error->message : "No connection to service manager.");
+                        log_error("Failed to get D-Bus connection: %s", strerror (-r));
                         return -EIO;
                 }
 
         } else {
 
                 if (!bus && !avoid_bus()) {
-                        log_error("Failed to get D-Bus connection: %s",
-                                  dbus_error_is_set(error) ? error->message : "No connection to service manager.");
+                        log_error("Failed to get D-Bus connection: %s", strerror (-r));
                         return -EIO;
                 }
         }
@@ -5902,7 +5338,7 @@ static int send_shutdownd(usec_t t, char mode, bool dry_run, bool warn, const ch
         return 0;
 }
 
-static int reload_with_fallback(DBusConnection *bus) {
+static int reload_with_fallback(sd_bus *bus) {
 
         if (bus) {
                 /* First, try systemd via D-Bus. */
@@ -5921,7 +5357,7 @@ static int reload_with_fallback(DBusConnection *bus) {
         return 0;
 }
 
-static int start_with_fallback(DBusConnection *bus) {
+static int start_with_fallback(sd_bus *bus) {
 
         if (bus) {
                 /* First, try systemd via D-Bus. */
@@ -5972,7 +5408,7 @@ static _noreturn_ void halt_now(enum action a) {
         assert_not_reached("Uh? This shouldn't happen.");
 }
 
-static int halt_main(DBusConnection *bus) {
+static int halt_main(sd_bus *bus) {
         int r;
 
         r = check_inhibitors(bus, arg_action);
@@ -6060,11 +5496,8 @@ static int runlevel_main(void) {
 }
 
 int main(int argc, char*argv[]) {
+        _cleanup_bus_unref_ sd_bus *bus = NULL;
         int r, retval = EXIT_FAILURE;
-        DBusConnection *bus = NULL;
-        _cleanup_dbus_error_free_ DBusError error;
-
-        dbus_error_init(&error);
 
         setlocale(LC_ALL, "");
         log_parse_environment();
@@ -6098,22 +5531,18 @@ int main(int argc, char*argv[]) {
         }
 
         if (!avoid_bus()) {
-                if (arg_transport == TRANSPORT_NORMAL)
-                        bus_connect(arg_scope == UNIT_FILE_SYSTEM ? DBUS_BUS_SYSTEM : DBUS_BUS_SESSION, &bus, &private_bus, &error);
-                else if (arg_transport == TRANSPORT_POLKIT) {
-                        bus_connect_system_polkit(&bus, &error);
-                        private_bus = false;
-                } else if (arg_transport == TRANSPORT_SSH) {
-                        bus_connect_system_ssh(arg_user, arg_host, &bus, &error);
-                        private_bus = false;
-                } else
-                        assert_not_reached("Uh, invalid transport...");
+                r = bus_open_transport(arg_transport, arg_host, arg_scope != UNIT_FILE_SYSTEM, &bus);
+                if (r < 0) {
+                        log_error("Failed to create bus connection: %s", strerror(-r));
+                        retval = EXIT_FAILURE;
+                        goto finish;
+                }
         }
 
         switch (arg_action) {
 
         case ACTION_SYSTEMCTL:
-                r = systemctl_main(bus, argc, argv, &error);
+                r = systemctl_main(bus, argc, argv, r);
                 break;
 
         case ACTION_HALT:
@@ -6164,14 +5593,6 @@ int main(int argc, char*argv[]) {
         retval = r < 0 ? EXIT_FAILURE : r;
 
 finish:
-        if (bus) {
-                dbus_connection_flush(bus);
-                dbus_connection_close(bus);
-                dbus_connection_unref(bus);
-        }
-
-        dbus_shutdown();
-
         strv_free(arg_types);
         strv_free(arg_states);
         strv_free(arg_properties);
-- 
1.8.4.2



More information about the systemd-devel mailing list