[systemd-devel] [PATCH V2 2/2] systemctl: port to libsystemd-bus
Marc-Antoine Perennou
Marc-Antoine at Perennou.com
Thu Nov 7 17:34:34 PST 2013
---
Makefile.am | 6 +-
src/systemctl/systemctl.c | 2342 +++++++++++++++++----------------------------
2 files changed, 882 insertions(+), 1466 deletions(-)
diff --git a/Makefile.am b/Makefile.am
index 8d3d451..dcbb15d 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1783,15 +1783,11 @@ 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-dbus.la \
libsystemd-logs.la \
+ libsystemd-bus-internal.la \
libsystemd-login-internal.la \
libsystemd-journal-internal.la \
libsystemd-id128-internal.la \
diff --git a/src/systemctl/systemctl.c b/src/systemctl/systemctl.c
index 631cd3d..e3f5794 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
@@ -36,12 +37,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"
@@ -51,7 +56,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"
@@ -126,22 +130,26 @@ 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_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)
@@ -178,26 +186,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)
@@ -417,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;
@@ -430,42 +437,42 @@ 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;
- }
+ r = sd_bus_message_enter_container(*reply, SD_BUS_TYPE_ARRAY, "(ssssssouso)");
+ if(r < 0)
+ return bus_log_parse_error(r);
- 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)++;
+ r = bus_message_read_unit_info(*reply, *unit_infos + *c);
+ if (r < 0)
+ return bus_log_parse_error(r);
- dbus_message_iter_next(&sub);
+ (*c)++;
}
+ r = sd_bus_message_exit_container(*reply);
+ if (r < 0)
+ return bus_log_parse_error(r);
+
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;
@@ -484,116 +491,59 @@ 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;
-
- 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;
-
- (*c) ++;
- }
+ r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ss)");
+ if (r < 0)
+ return bus_log_parse_error(r);
- dbus_message_iter_next(&sub);
+ while ((r = sd_bus_message_read(reply, "(ss)", &type, &path)) > 0) {
+ r = strv_extend(listen, type);
+ if (r < 0)
+ return r;
+ r = strv_extend(listen, path);
+ if (r < 0)
+ return r;
+ (*c)++;
}
+ if (r == 0)
+ r = sd_bus_message_exit_container(reply);
+ if (r < 0)
+ return bus_log_parse_error(r);
return 0;
}
@@ -683,8 +633,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;
@@ -841,11 +791,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();
@@ -880,32 +832,24 @@ 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;
- }
-
- dbus_message_iter_recurse(&iter, &sub);
+ r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ss)");
+ if (r < 0)
+ return bus_log_parse_error(r);
- 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;
@@ -919,20 +863,15 @@ 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)
+ r = sd_bus_message_exit_container(reply);
+ if (r < 0)
+ return bus_log_parse_error(r);
}
if (c > 0) {
@@ -979,7 +918,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"
@@ -994,101 +933,76 @@ 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);
+ r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "{sv}");
+ if (r < 0)
+ return bus_log_parse_error(r);
- 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 (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &prop, true) < 0) {
- log_error("Failed to parse reply.");
- r = -EIO;
- goto finish;
- }
+ r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_DICT_ENTRY, "sv");
+ if (r >= 0)
+ r = sd_bus_message_read_basic(reply, SD_BUS_TYPE_STRING, &prop);
+ if (r < 0)
+ goto fail;
- 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)) {
+ r = sd_bus_message_skip(reply, "v");
+ if (r < 0)
+ goto fail;
+ goto next;
}
- dbus_message_iter_recurse(&sub2, &sub3);
- dbus_message_iter_next(&sub);
-
- 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);
+ r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_VARIANT, "as");
+ if (r >= 0)
+ r = bus_message_read_strv_extend(reply, &ret);
+ if (r >= 0)
+ r = sd_bus_message_exit_container(reply);
- while (dbus_message_iter_get_arg_type(&sub4) != DBUS_TYPE_INVALID) {
- const char *s;
+next:
+ if (r >= 0)
+ r = sd_bus_message_exit_container(reply);
+ if (r < 0)
+ goto fail;
+ }
- assert(dbus_message_iter_get_arg_type(&sub4) == DBUS_TYPE_STRING);
- dbus_message_iter_get_basic(&sub4, &s);
+ r = sd_bus_message_exit_container(reply);
+ if (r < 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 bus_log_parse_error(r);
}
static int list_dependencies_compare(const void *_a, const void *_b) {
@@ -1100,7 +1014,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;
@@ -1143,7 +1057,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;
@@ -1165,57 +1079,42 @@ 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;
- }
+ r = sd_bus_message_read_basic(reply, SD_BUS_TYPE_STRING, &path);
+ if (r < 0)
+ return bus_log_parse_error(r);
}
if (path)
printf("%s\n", path);
-finish:
- if ((!bus || avoid_bus()) && path)
- free(path);
-
- return r;
-
+ return 0;
}
struct job_info {
@@ -1288,56 +1187,32 @@ 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;
+ return log_method_call_failed("list jobs", &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;
- }
-
- 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;
- }
+ r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(usssoo)");
+ if (r < 0)
+ return bus_log_parse_error(r);
+ 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;
@@ -1351,11 +1226,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--) {
@@ -1365,10 +1240,11 @@ static int list_jobs(DBusConnection *bus, char **args) {
}
free(jobs);
- return r;
+ return 0;
}
-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);
@@ -1386,87 +1262,64 @@ 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;
+ r = sd_bus_message_read_basic (reply, SD_BUS_TYPE_OBJECT_PATH, &path);
+ if (r < 0)
+ return bus_log_parse_error(r);
- r = bus_method_call_with_reply(
+ r = sd_bus_get_property_trivial(
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;
+ return log_method_call_failed("get property", &error, -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;
-
- dbus_message_iter_get_basic(&sub, &b);
return b;
}
@@ -1477,42 +1330,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);
@@ -1520,57 +1365,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;
}
@@ -1578,21 +1411,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)
@@ -1624,89 +1463,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;
- _cleanup_free_ char *n = NULL;
- DBusMessageIter iter, sub;
- const char
- *interface = "org.freedesktop.systemd1.Unit",
- *property = "ActiveState";
- const char *state, *path;
- DBusError error;
+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, *state = NULL;
+ const char *path;
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;
- }
+ r = sd_bus_message_read_basic(reply, SD_BUS_TYPE_OBJECT_PATH, &path);
+ return bus_log_parse_error(r);
- dbus_message_unref(reply);
- reply = NULL;
-
- r = bus_method_call_with_reply(
+ r = sd_bus_get_property_string(
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,
+ &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);
@@ -1714,17 +1520,18 @@ 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_free_ char *unit_path = NULL, *n = NULL;
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+ _cleanup_free_ char *unit_path = NULL, *n = NULL, *state = NULL;
+ _cleanup_strv_free_ char **triggered_by = NULL;
bool print_warning_label = true;
+ char **service_trigger;
+ const char * const check_states[] = {
+ "active",
+ "reloading",
+ NULL
+ };
int r;
n = unit_name_mangle(unit_name);
@@ -1739,81 +1546,30 @@ static void check_triggering_units(
return;
}
- r = bus_method_call_with_reply(
+ r = sd_bus_get_property_string(
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,
+ &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) {
@@ -1822,22 +1578,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;
@@ -1851,34 +1604,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;
- }
+ r = sd_bus_message_read_basic(reply, SD_BUS_TYPE_OBJECT_PATH, &path);
+ return bus_log_parse_error(r);
if (need_daemon_reload(bus, n) > 0)
log_warning("Warning: Unit file of %s changed on disk, 'systemctl %sdaemon-reload' recommended.",
@@ -1932,15 +1677,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);
@@ -1970,7 +1712,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);
@@ -2000,10 +1741,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);
- }
}
}
@@ -2028,10 +1767,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;
@@ -2064,29 +1804,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;
@@ -2103,52 +1848,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;
- }
+ r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "ssssuu");
+ return bus_log_parse_error(r);
- 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)
@@ -2159,24 +1880,22 @@ 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)
+ r = sd_bus_message_exit_container(reply);
+ if (r < 0)
+ return bus_log_parse_error(r);
/* 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())
@@ -2209,7 +1928,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;
@@ -2259,7 +1978,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",
@@ -2285,7 +2004,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
@@ -2310,7 +2029,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;
@@ -2327,20 +2047,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;
}
@@ -2371,72 +2088,37 @@ 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(m);
assert(i);
- assert(i);
-
- if (dbus_message_iter_get_arg_type(sub) != DBUS_TYPE_STRUCT)
- return -EIO;
-
- dbus_message_iter_recurse(sub, &sub2);
- if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, true) < 0)
- return -EIO;
+ r = sd_bus_message_enter_container(m, SD_BUS_TYPE_STRUCT, "sasbttttuii");
+ if (r == 0)
+ return 0;
+ else if (r > 0)
+ r = sd_bus_message_read_basic(m, SD_BUS_TYPE_STRING, &path);
+ if (r < 0)
+ return bus_log_parse_error(r);
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;
+ r = sd_bus_message_read_strv(m, &i->argv);
+ if (r >= 0)
+ r = sd_bus_message_read(m, "bttttuii", &ignore,
+ &start_timestamp, &start_timestamp_monotonic,
+ &exit_timestamp, &exit_timestamp_monotonic,
+ &pid, &code, &status);
+ if (r < 0)
+ return bus_log_parse_error(r);
i->ignore = ignore;
i->start_timestamp = (usec_t) start_timestamp;
@@ -2445,7 +2127,11 @@ static int exec_status_info_deserialize(DBusMessageIter *sub, ExecStatusInfo *i)
i->code = code;
i->status = status;
- return 0;
+ r = sd_bus_message_exit_container(m);
+ if (r < 0)
+ return bus_log_parse_error(r);
+
+ return 1;
}
typedef struct UnitStatusInfo {
@@ -2761,7 +2447,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[] = " ";
@@ -2783,7 +2469,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,
@@ -2860,18 +2546,20 @@ 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);
+ r = sd_bus_message_read_basic(m, SD_BUS_TYPE_STRING, &s);
+ if (r < 0)
+ return bus_log_parse_error(r);
if (!isempty(s)) {
if (streq(name, "Id"))
@@ -2918,11 +2606,12 @@ 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);
+ r = sd_bus_message_read_basic(m, SD_BUS_TYPE_BOOLEAN, &b);
+ if (r < 0)
+ return bus_log_parse_error(r);
if (streq(name, "Accept"))
i->accept = b;
@@ -2933,11 +2622,12 @@ 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);
+ r = sd_bus_message_read_basic(m, SD_BUS_TYPE_UINT32, &u);
+ if (r < 0)
+ return bus_log_parse_error(r);
if (streq(name, "MainPID")) {
if (u > 0) {
@@ -2956,11 +2646,12 @@ 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);
+ r = sd_bus_message_read_basic(m, SD_BUS_TYPE_INT32, &j);
+ if (r < 0)
+ return bus_log_parse_error(r);
if (streq(name, "ExecMainCode"))
i->exit_code = (int) j;
@@ -2969,11 +2660,12 @@ 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);
+ r = sd_bus_message_read_basic(m, SD_BUS_TYPE_UINT64, &u);
+ if (r < 0)
+ return bus_log_parse_error(r);
if (streq(name, "ExecMainStartTimestamp"))
i->start_timestamp = (usec_t) u;
@@ -2994,156 +2686,111 @@ 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 (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;
- int r;
-
- info = new0(ExecStatusInfo, 1);
- if (!info)
- return -ENOMEM;
-
- 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;
+ r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sasbttttuii)");
+ if (r < 0)
+ return bus_log_parse_error(r);
- dbus_message_iter_recurse(&sub, &sub2);
+ info = new0(ExecStatusInfo, 1);
+ if (!info)
+ return -ENOMEM;
- 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;
+ while ((r = exec_status_info_deserialize(m, info)) > 0) {
+ info->name = strdup(name);
+ if (!info->name)
+ return -ENOMEM;
- r = strv_extend(&i->listen, type);
- if (r < 0)
- return r;
- r = strv_extend(&i->listen, path);
- if (r < 0)
- return r;
- }
+ LIST_PREPEND(exec, i->exec, info);
- dbus_message_iter_next(&sub);
+ info = new0(ExecStatusInfo, 1);
+ if (!info)
+ return -ENOMEM;
}
+ } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Listen")) {
+ const char *type, *path;
- return 0;
-
- } 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);
+ r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ss)");
if (r < 0)
- return r;
-
- } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRING &&
- streq(name, "Documentation")) {
+ return bus_log_parse_error(r);
- 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);
}
-
- } 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, ¶m, 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;
- }
+ } else if (contents[1] == SD_BUS_TYPE_STRING && streq(name, "DropInPaths")) {
+ r = sd_bus_message_read_strv(m, &i->dropin_paths);
+ if (r < 0)
+ return bus_log_parse_error(r);
+ return 0;
+ } else if (contents[1] == SD_BUS_TYPE_STRING && streq(name, "Documentation")) {
+ r = sd_bus_message_read_strv(m, &i->documentation);
+ if (r < 0)
+ return bus_log_parse_error(r);
+ return 0;
+ } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Conditions")) {
+ const char *cond, *param;
+ bool trigger, negate;
+ int32_t state;
+
+ r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sbbsi)");
+ return bus_log_parse_error(r);
+
+ while ((r = sd_bus_message_read(m, "(sbbsi)", &cond, &trigger, &negate, ¶m, &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);
}
- }
-
- break;
- }
+ } else goto skip;
- case DBUS_TYPE_STRUCT: {
+ if (r == 0)
+ r = sd_bus_message_exit_container(m);
+ if (r < 0)
+ return bus_log_parse_error(r);
+ return 0;
+ }
+ 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);
+ r = sd_bus_message_read(m, "(ss)", &n, &message);
if (r < 0)
- return r;
-
- r = bus_iter_get_basic_and_next(&sub, DBUS_TYPE_STRING, &message, false);
- if (r < 0)
- return r;
+ return bus_log_parse_error(r);
if (!isempty(message))
i->load_error = message;
- }
+ } else goto skip;
break;
}
+ default: goto skip;
}
return 0;
+
+skip:
+ r = sd_bus_message_skip(m, contents);
+ return bus_log_parse_error(r);
+
+ 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 */
@@ -3151,16 +2798,15 @@ 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;
+ const char *o;
- dbus_message_iter_get_basic(&sub, &u);
+ r = sd_bus_message_read(m, "(uo)", &u, &o);
+ if (r < 0)
+ return bus_log_parse_error(r);
if (u)
printf("%s=%u\n", name, (unsigned) u);
@@ -3168,20 +2814,22 @@ static int print_property(const char *name, DBusMessageIter *iter) {
printf("%s=\n", name);
return 0;
- } else if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING && streq(name, "Unit")) {
- const char *s;
+ } else if (contents[1] == SD_BUS_TYPE_STRING && streq(name, "Unit")) {
+ const char *s, *o;
- dbus_message_iter_get_basic(&sub, &s);
+ r = sd_bus_message_read(m, "(ss)", &s, &o);
+ return bus_log_parse_error(r);
if (arg_all || s[0])
printf("%s=%s\n", name, s);
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);
+ r = sd_bus_message_read(m, "(ss)", &a, &b);
+ if (r < 0)
+ return bus_log_parse_error(r);
if (arg_all || !isempty(a) || !isempty(b))
printf("%s=%s \"%s\"\n", name, strempty(a), strempty(b));
@@ -3191,262 +2839,196 @@ 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;
-
- 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);
- }
-
- return 0;
-
- } 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;
+ r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sb)");
+ if (r < 0)
+ return bus_log_parse_error(r);
- dbus_message_iter_recurse(&sub, &sub2);
+ while ((r = sd_bus_message_read(m, "(sb)", &path, &ignore)) > 0)
+ printf("EnvironmentFile=%s (ignore_errors=%s)\n", path, yes_no(ignore));
+ } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Paths")) {
+ const char *type, *path;
- 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];
+ r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ss)");
+ if (r < 0)
+ return bus_log_parse_error(r);
- printf("%s={ value=%s ; next_elapse=%s }\n",
- base,
- format_timespan(timespan1, sizeof(timespan1), value, 0),
- format_timespan(timespan2, sizeof(timespan2), next_elapse, 0));
- }
+ while ((r = sd_bus_message_read(m, "(ss)", &type, &path)) > 0)
+ printf("%s=%s\n", type, path);
+ } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Listen")) {
+ const char *type, *path;
- dbus_message_iter_next(&sub);
+ r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ss)");
+ if (r < 0)
+ return bus_log_parse_error(r);
+
+ while ((r = sd_bus_message_read(m, "(ss)", &type, &path)) > 0)
+ printf("Listen%s=%s\n", type, path);
+ } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Timers")) {
+ const char *base;
+ uint64_t value, next_elapse;
+
+ r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(stt)");
+ return bus_log_parse_error(r);
+
+ 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));
}
-
- 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)));
- }
+ } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && startswith(name, "Exec")) {
+ ExecStatusInfo info = {};
+
+ r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sasbttttuii)");
+ return bus_log_parse_error(r);
+
+ 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)));
free(info.path);
strv_free(info.argv);
-
- dbus_message_iter_next(&sub);
+ zero(info);
}
+ } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "DeviceAllow")) {
+ const char *path, *rwm;
- return 0;
-
- } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "DeviceAllow")) {
- DBusMessageIter sub, sub2;
-
- dbus_message_iter_recurse(iter, &sub);
- while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
- const char *path, *rwm;
-
- 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_STRING, &rwm, false) >= 0)
- printf("%s=%s %s\n", name, strna(path), strna(rwm));
-
- dbus_message_iter_next(&sub);
- }
- return 0;
-
- } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "BlockIODeviceWeight")) {
- DBusMessageIter sub, sub2;
-
- dbus_message_iter_recurse(iter, &sub);
- while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
- const char *path;
- uint64_t weight;
-
- 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_UINT64, &weight, false) >= 0)
- printf("%s=%s %" PRIu64 "\n", name, strna(path), weight);
-
- dbus_message_iter_next(&sub);
- }
- return 0;
+ r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ss)");
+ return bus_log_parse_error(r);
- } 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, "(ss)", &path, &rwm)) > 0)
+ printf("%s=%s %s\n", name, strna(path), strna(rwm));
+ } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "BlockIODeviceWeight")) {
+ const char *path;
+ uint64_t weight;
- dbus_message_iter_recurse(iter, &sub);
- while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
- const char *path;
- uint64_t bandwidth;
+ r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(st)");
+ if (r < 0)
+ return bus_log_parse_error(r);
- dbus_message_iter_recurse(&sub, &sub2);
+ while ((r = sd_bus_message_read(m, "(st)", &path, &weight)) > 0)
+ printf("%s=%s %" PRIu64 "\n", name, strna(path), weight);
+ } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && (streq(name, "BlockIOReadBandwidth") || streq(name, "BlockIOWriteBandwidth"))) {
+ const char *path;
+ uint64_t bandwidth;
- 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);
+ r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(st)");
+ return bus_log_parse_error(r);
- dbus_message_iter_next(&sub);
- }
- return 0;
- }
+ while ((r = sd_bus_message_read(m, "(st)", &path, &bandwidth)) > 0)
+ printf("%s=%s %" PRIu64 "\n", name, strna(path), bandwidth);
+ } else break;
+ if (r == 0)
+ r = sd_bus_message_exit_container(m);
+ if (r < 0)
+ return bus_log_parse_error(r);
- break;
+ return 0;
}
+ }
+
+ r = bus_print_property(name, m, arg_all);
+ if (r < 0)
+ return bus_log_parse_error(r);
- if (generic_print_property(name, iter, arg_all) > 0)
- return 0;
+ if (r == 0) {
+ r = sd_bus_message_skip(m, contents);
+ if (r < 0)
+ return bus_log_parse_error(r);
- if (arg_all)
- printf("%s=[unprintable]\n", name);
+ 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;
-
- 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;
- }
+ return log_method_call_failed("get properties", &error, -r);
- dbus_message_iter_recurse(&iter, &sub);
+ r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "{sv}");
+ return bus_log_parse_error(r);
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);
+ r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_DICT_ENTRY, "sv");
+ if (r >= 0)
+ r = sd_bus_message_read_basic(reply, SD_BUS_TYPE_STRING, &name);
+ if (r >= 0)
+ r = sd_bus_message_peek_type(reply, NULL, &contents);
+ if (r >= 0)
+ r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_VARIANT, contents);
+ if (r < 0)
+ return bus_log_parse_error(r);
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)
+ r = sd_bus_message_exit_container(reply);
+ if (r >= 0)
+ r = sd_bus_message_exit_container(reply);
+ if (r < 0)
+ return bus_log_parse_error(r);
}
+ r = sd_bus_message_exit_container(reply);
+ if (r < 0)
+ return bus_log_parse_error(r);
+
r = 0;
if (!show_properties) {
@@ -3485,47 +3067,41 @@ 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;
- }
+ r = sd_bus_message_read_basic(reply, SD_BUS_TYPE_OBJECT_PATH, &path);
+ if (r < 0)
+ return bus_log_parse_error(r);
- 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;
@@ -3557,7 +3133,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;
@@ -3624,13 +3200,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, '=');
@@ -3642,14 +3217,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);
@@ -3657,10 +3232,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;
@@ -3672,10 +3248,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;
@@ -3685,26 +3262,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, ' ');
@@ -3721,26 +3300,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;
@@ -3766,27 +3342,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;
@@ -3809,101 +3381,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;
+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, *id = NULL;
+ const char *path;
int r;
- dbus_bool_t cleanup = FALSE;
- DBusMessageIter iter, sub;
- const char
- *path, *id,
- *interface = "org.freedesktop.systemd1.Unit",
- *property = "Id";
- _cleanup_free_ char *n = NULL;
-
- dbus_error_init(&error);
if (strv_length(args) > 1)
n = unit_name_mangle_with_suffix(args[1], ".snapshot");
@@ -3912,59 +3469,32 @@ 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;
+ return log_method_call_failed("create snapshot", &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));
- dbus_error_free(&error);
- return -EIO;
- }
-
- dbus_message_unref(reply);
- reply = NULL;
+ r = sd_bus_message_read_basic(reply, SD_BUS_TYPE_OBJECT_PATH, &path);
+ if (r < 0)
+ return bus_log_parse_error(r);
- r = bus_method_call_with_reply (
+ r = sd_bus_get_property_string(
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,
+ &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);
@@ -3972,40 +3502,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";
@@ -4027,15 +3557,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
@@ -4046,15 +3576,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);
@@ -4066,84 +3596,54 @@ 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_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+ _cleanup_strv_free_ char **strv;
+ 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_strv(
bus,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
- "org.freedesktop.DBus.Properties",
- "Get",
- &reply,
- NULL,
- DBUS_TYPE_STRING, &interface,
- DBUS_TYPE_STRING, &property,
- DBUS_TYPE_INVALID);
+ "org.freedesktop.systemd1.Manager",
+ "Environment",
+ &error,
+ &strv);
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;
-
- if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_STRING) {
- log_error("Failed to parse reply.");
- return -EIO;
- }
-
- dbus_message_iter_get_basic(&sub2, &text);
- puts(text);
+ return log_method_call_failed("get environment", &error, -r);
- dbus_message_iter_next(&sub2);
+ STRV_FOREACH(text, strv) {
+ puts(*text);
}
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) {
@@ -4168,55 +3668,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;
}
@@ -4411,17 +3907,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;
@@ -4473,10 +3967,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";
@@ -4502,103 +3994,62 @@ 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;
+ r = sd_bus_message_read_basic(reply, SD_BUS_TYPE_BOOLEAN, &carries_install_info);
+ if (r < 0)
+ return bus_log_parse_error(r);
}
- 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;
- }
+ r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(sss)");
+ if (r < 0)
+ return bus_log_parse_error(r);
+ 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)
+ r = sd_bus_message_exit_container(reply);
+ if (r < 0)
+ return bus_log_parse_error(r);
/* Try to reload if enabeld */
if (!arg_no_reload)
r = daemon_reload(bus, args);
+ else
+ r = 0;
}
if (carries_install_info == 0)
@@ -4618,16 +4069,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;
@@ -4661,29 +4110,21 @@ 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;
+ r = sd_bus_message_read(reply, "s", &s);
+ if (r < 0)
+ return bus_log_parse_error(r);
if (streq(s, "enabled") ||
streq(s, "enabled-runtime") ||
@@ -4692,6 +4133,9 @@ static int unit_is_enabled(DBusConnection *bus, char **args) {
if (!arg_quiet)
puts(s);
+
+ sd_bus_message_unref(reply);
+ reply = NULL;
}
}
@@ -4727,7 +4171,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"
@@ -4959,7 +4402,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' },
@@ -4973,7 +4415,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) {
@@ -5165,12 +4607,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;
@@ -5228,7 +4666,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;
}
@@ -5703,7 +5141,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;
@@ -5713,7 +5151,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 },
@@ -5744,7 +5182,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 },
@@ -5779,7 +5217,6 @@ static int systemctl_main(DBusConnection *bus, int argc, char *argv[], DBusError
assert(argc >= 0);
assert(argv);
- assert(error);
left = argc - optind;
@@ -5855,16 +5292,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;
}
}
@@ -5913,7 +5348,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. */
@@ -5932,7 +5367,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. */
@@ -5991,7 +5426,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);
@@ -6079,11 +5514,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();
@@ -6117,22 +5549,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:
@@ -6183,14 +5611,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