HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/shared/bus-unit-util.c

142,933 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: f394de58800f6f44c8671d3ee9abcf76abdcad20

Lines 1–1000 of 3,301

/* SPDX-License-Identifier: LGPL-2.1-or-later */
 
#include <paths.h>
#include <sys/mount.h>
 
#include "sd-bus.h"
 
#include "alloc-util.h"
#include "bus-common-errors.h"
#include "bus-error.h"
#include "bus-locator.h"
#include "bus-unit-util.h"
#include "bus-util.h"
#include "capability-list.h"
#include "cgroup-setup.h"
#include "cgroup-util.h"
#include "condition.h"
#include "constants.h"
#include "coredump-util.h"
#include "cpu-set-util.h"
#include "escape.h"
#include "exec-util.h"
#include "exit-status.h"
#include "extract-word.h"
#include "firewall-util.h"
#include "hexdecoct.h"
#include "hostname-util.h"
#include "in-addr-util.h"
#include "install.h"
#include "ioprio-util.h"
#include "ip-protocol-list.h"
#include "log.h"
#include "mountpoint-util.h"
#include "nsflags.h"
#include "numa-util.h"
#include "open-file.h"
#include "parse-helpers.h"
#include "parse-util.h"
#include "path-util.h"
#include "percent-util.h"
#include "pidref.h"
#include "process-util.h"
#include "rlimit-util.h"
#include "seccomp-util.h"
#include "securebits-util.h"
#include "signal-util.h"
#include "socket-util.h"
#include "string-util.h"
#include "syslog-util.h"
#include "time-util.h"
#include "unit-def.h"
 
int bus_parse_unit_info(sd_bus_message *message, UnitInfo *u) {
        assert(message);
        assert(u);
 
        u->machine = NULL;
 
        return sd_bus_message_read(
                        message,
                        "(ssssssouso)",
                        &u->id,
                        &u->description,
                        &u->load_state,
                        &u->active_state,
                        &u->sub_state,
                        &u->following,
                        &u->unit_path,
                        &u->job_id,
                        &u->job_type,
                        &u->job_path);
}
 
static int warn_deprecated(_unused_ sd_bus_message *m, const char *field, const char *eq) {
        log_warning("D-Bus property %s is deprecated, ignoring assignment: %s=%s", field, field, eq);
        return 1;
}
 
static int parse_log_error(int error, const char *field, const char *eq) {
        if (error == -ENOMEM)
                return log_oom();
        if (error != 0)  /* Allow SYNTHETIC_ERRNO to be used, i.e. positive values. */
                return log_error_errno(error, "Failed to parse %s= value '%s': %m", field, eq);
 
        /* We don't log the error value for cases where we have a general "syntax error". */
        return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                               "Invalid syntax for %s= value: '%s'", field, eq);
}
 
#define DEFINE_BUS_APPEND_PARSE_PTR(bus_type, cast_type, type, parse_func) \
        static int bus_append_##parse_func(                             \
                        sd_bus_message *m,                              \
                        const char *field,                              \
                        const char *eq) {                               \
                type val;                                               \
                int r;                                                  \
                                                                        \
                r = parse_func(eq, &val);                               \
                if (r < 0)                                              \
                        return parse_log_error(r, field, eq);           \
                                                                        \
                r = sd_bus_message_append(m, "(sv)", field,             \
                                          bus_type, (cast_type) val);   \
                if (r < 0)                                              \
                        return bus_log_create_error(r);                 \
                                                                        \
                return 1;                                               \
        }
 
#define DEFINE_BUS_APPEND_PARSE(bus_type, parse_func)                   \
        static int bus_append_##parse_func(                             \
                        sd_bus_message *m,                              \
                        const char *field,                              \
                        const char *eq) {                               \
                int r;                                                  \
                                                                        \
                r = parse_func(eq);                                     \
                if (r < 0)                                              \
                        return parse_log_error(r, field, eq);           \
                                                                        \
                r = sd_bus_message_append(m, "(sv)", field,             \
                                          bus_type, (int32_t) r);       \
                if (r < 0)                                              \
                        return bus_log_create_error(r);                 \
                                                                        \
                return 1;                                               \
        }
 
DEFINE_BUS_APPEND_PARSE("b", parse_boolean);
DEFINE_BUS_APPEND_PARSE("i", ioprio_class_from_string);
DEFINE_BUS_APPEND_PARSE("i", ip_tos_from_string);
DEFINE_BUS_APPEND_PARSE("i", log_facility_unshifted_from_string);
DEFINE_BUS_APPEND_PARSE("i", log_level_from_string);
DEFINE_BUS_APPEND_PARSE("i", seccomp_parse_errno_or_action);
DEFINE_BUS_APPEND_PARSE("i", sched_policy_from_string);
DEFINE_BUS_APPEND_PARSE("i", secure_bits_from_string);
DEFINE_BUS_APPEND_PARSE("i", signal_from_string);
DEFINE_BUS_APPEND_PARSE("i", parse_ip_protocol);
DEFINE_BUS_APPEND_PARSE("i", mpol_from_string);
DEFINE_BUS_APPEND_PARSE_PTR("i", int32_t, int, ioprio_parse_priority);
DEFINE_BUS_APPEND_PARSE_PTR("i", int32_t, int, parse_nice);
DEFINE_BUS_APPEND_PARSE_PTR("i", int32_t, int, safe_atoi);
DEFINE_BUS_APPEND_PARSE_PTR("t", uint64_t, nsec_t, parse_nsec);
DEFINE_BUS_APPEND_PARSE_PTR("t", uint64_t, uint64_t, cg_weight_parse);
DEFINE_BUS_APPEND_PARSE_PTR("t", uint64_t, uint64_t, cg_cpu_weight_parse);
DEFINE_BUS_APPEND_PARSE_PTR("t", uint64_t, unsigned long, mount_propagation_flag_from_string);
DEFINE_BUS_APPEND_PARSE_PTR("t", uint64_t, uint64_t, safe_atou64);
DEFINE_BUS_APPEND_PARSE_PTR("u", uint32_t, mode_t, parse_mode);
DEFINE_BUS_APPEND_PARSE_PTR("u", uint32_t, unsigned, safe_atou);
DEFINE_BUS_APPEND_PARSE_PTR("x", int64_t, int64_t, safe_atoi64);
DEFINE_BUS_APPEND_PARSE_PTR("t", uint64_t, uint64_t, coredump_filter_mask_from_string);
 
static int bus_append_string(sd_bus_message *m, const char *field, const char *eq) {
        int r;
 
        r = sd_bus_message_append(m, "(sv)", field, "s", eq);
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_strv_full(sd_bus_message *m, const char *field, const char *eq, const char *separators, ExtractFlags flags) {
        int r;
 
        assert(m);
        assert(field);
 
        r = sd_bus_message_open_container(m, 'r', "sv");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_append_basic(m, 's', field);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_open_container(m, 'v', "as");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_open_container(m, 'a', "s");
        if (r < 0)
                return bus_log_create_error(r);
 
        for (const char *p = eq;;) {
                _cleanup_free_ char *word = NULL;
 
                r = extract_first_word(&p, &word, separators, flags);
                if (r < 0)
                        return parse_log_error(r, field, eq);
                if (r == 0)
                        break;
 
                r = sd_bus_message_append_basic(m, 's', word);
                if (r < 0)
                        return bus_log_create_error(r);
        }
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_strv(sd_bus_message *m, const char *field, const char *eq) {
        return bus_append_strv_full(m, field, eq, /* separators= */ NULL, EXTRACT_UNQUOTE);
}
 
static int bus_append_strv_cunescape(sd_bus_message *m, const char *field, const char *eq) {
        return bus_append_strv_full(m, field, eq, /* separators= */ NULL, EXTRACT_UNQUOTE | EXTRACT_CUNESCAPE);
}
 
static int bus_append_strv_colon(sd_bus_message *m, const char *field, const char *eq) {
        /* This also accepts colon as the separator. */
        return bus_append_strv_full(m, field, eq, ":" WHITESPACE, EXTRACT_UNQUOTE);
}
 
static int bus_append_xattr(sd_bus_message *m, const char *field, const char *eq) {
        int r;
 
        assert(m);
        assert(field);
 
        /* Sends an extended attribute assignment of the form "name=value" as an a(ss) array of one
         * name/value pair (or as an empty array if the value is empty, which resets the list). */
 
        r = sd_bus_message_open_container(m, 'r', "sv");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_append_basic(m, 's', field);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_open_container(m, 'v', "a(ss)");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_open_container(m, 'a', "(ss)");
        if (r < 0)
                return bus_log_create_error(r);
 
        if (!isempty(eq)) {
                _cleanup_free_ char *name = NULL, *value = NULL;
 
                r = split_pair(eq, "=", &name, &value);
                if (r < 0)
                        return log_error_errno(r, "Failed to parse extended attribute expression '%s': %m", eq);
 
                r = sd_bus_message_append(m, "(ss)", name, value);
                if (r < 0)
                        return bus_log_create_error(r);
        }
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_byte_array(sd_bus_message *m, const char *field, const void *buf, size_t n) {
        int r;
 
        r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, field);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_open_container(m, 'v', "ay");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_append_array(m, 'y', buf, n);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_parse_sec_rename(sd_bus_message *m, const char *field, const char *eq) {
        char *n;
        usec_t t;
        size_t l;
        int r;
 
        r = parse_sec(eq, &t);
        if (r < 0)
                return parse_log_error(r, field, eq);
 
        l = strlen(field);
        n = newa(char, l + 2);
        /* Change suffix Sec → USec */
        strcpy(mempcpy(n, field, l - 3), "USec");
 
        r = sd_bus_message_append(m, "(sv)", n, "t", t);
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_parse_sec_rename_infinity(sd_bus_message *m, const char *field, const char *eq) {
        return bus_append_parse_sec_rename(m, field, isempty(eq) ? "infinity" : eq);
}
 
static int bus_append_parse_size(sd_bus_message *m, const char *field, const char *eq) {
        uint64_t v;
        int r;
 
        r = parse_size(eq, /* base= */ 1024, &v);
        if (r < 0)
                return parse_log_error(r, field, eq);
 
        r = sd_bus_message_append(m, "(sv)", field, "t", v);
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_parse_size_i64(sd_bus_message *m, const char *field, const char *eq) {
        uint64_t v;
        int r;
 
        r = parse_size(eq, /* base= */ 1024, &v);
        if (r < 0)
                return parse_log_error(r, field, eq);
        if (v > INT64_MAX)
                return parse_log_error(SYNTHETIC_ERRNO(ERANGE), field, eq);
 
        r = sd_bus_message_append(m, "(sv)", field, "x", (int64_t) v);
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_parse_permyriad(sd_bus_message *m, const char *field, const char *eq) {
        int r;
 
        r = parse_permyriad(eq);
        if (r < 0)
                return parse_log_error(r, field, eq);
 
        /* Pass around scaled to 2^32-1 == 100% */
        r = sd_bus_message_append(m, "(sv)", field, "u", UINT32_SCALE_FROM_PERMYRIAD(r));
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_parse_cpu_set(sd_bus_message *m, const char *field, const char *eq) {
        _cleanup_(cpu_set_done) CPUSet cpuset = {};
        _cleanup_free_ uint8_t *array = NULL;
        size_t allocated;
        int r;
 
        r = parse_cpu_set(eq, &cpuset);
        if (r < 0)
                return parse_log_error(r, field, eq);
 
        r = cpu_set_to_dbus(&cpuset, &array, &allocated);
        if (r < 0)
                return log_error_errno(r, "Failed to serialize %s: %m", field);
 
        return bus_append_byte_array(m, field, array, allocated);
}
 
static int bus_append_parse_delegate(sd_bus_message *m, const char *field, const char *eq) {
        int r;
 
        r = parse_boolean(eq);
        if (r < 0)
                return bus_append_strv(m, "DelegateControllers", eq);
 
        r = sd_bus_message_append(m, "(sv)", "Delegate", "b", r);
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_parse_resource_limit(sd_bus_message *m, const char *field, const char *eq) {
        int r;
 
        if (isempty(eq) || streq(eq, "infinity")) {
                uint64_t x = streq(eq, "infinity") ? CGROUP_LIMIT_MAX :
                        STR_IN_SET(field,
                                   "MemoryLow",
                                   "MemoryMin") ? CGROUP_LIMIT_MIN : CGROUP_LIMIT_MAX;
 
                r = sd_bus_message_append(m, "(sv)", field, "t", x);
                if (r < 0)
                        return bus_log_create_error(r);
 
                return 1;
        }
 
        r = parse_permyriad(eq);
        if (r >= 0) {
                char *n;
 
                /* When this is a percentage we'll convert this into a relative value in the range
                 * 0…UINT32_MAX and pass it in the MemoryLowScale property (and related ones). This
                 * way the physical memory size can be determined server-side. */
 
                n = strjoina(field, "Scale");
                r = sd_bus_message_append(m, "(sv)", n, "u", UINT32_SCALE_FROM_PERMYRIAD(r));
                if (r < 0)
                        return bus_log_create_error(r);
 
                return 1;
        }
 
        if (streq(field, "TasksMax"))
                return bus_append_safe_atou64(m, field, eq);
 
        return bus_append_parse_size(m, field, eq);
}
 
static int bus_append_parse_cpu_quota(sd_bus_message *m, const char *field, const char *eq) {
        uint64_t x;
        int r;
 
        if (isempty(eq))
                x = USEC_INFINITY;
        else {
                r = parse_permyriad_unbounded(eq);
                if (r < 0)
                        return parse_log_error(r, field, eq);
                if (r == 0)
                        return parse_log_error(SYNTHETIC_ERRNO(ERANGE), field, eq);
                x = r * USEC_PER_SEC / 10000U;
        }
 
        r = sd_bus_message_append(m, "(sv)", "CPUQuotaPerSecUSec", "t", x);
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_parse_device_allow(sd_bus_message *m, const char *field, const char *eq) {
        int r;
 
        if (isempty(eq))
                r = sd_bus_message_append(m, "(sv)", field, "a(ss)", 0);
        else {
                _cleanup_free_ char *_path = NULL;
                const char *path = eq, *rwm = NULL, *e;
 
                e = strchr(eq, ' ');
                if (e) {
                        path = _path = strndup(eq, e - eq);
                        if (!path)
                                return log_oom();
 
                        rwm = e + 1;
                }
 
                r = sd_bus_message_append(m, "(sv)", field, "a(ss)", 1, path, strempty(rwm));
        }
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_try_append_parse_cgroup_io_limit(sd_bus_message *m, const char *field, const char *eq) {
        int r;
 
        if (cgroup_io_limit_type_from_string(field) < 0)
                return 0;
 
        if (isempty(eq))
                r = sd_bus_message_append(m, "(sv)", field, "a(st)", 0);
        else {
                const char *e = strchr(eq, ' ');
                if (!e)
                        return parse_log_error(0, field, eq);
 
                const char *bandwidth = e + 1;
                _cleanup_free_ char *path = strndup(eq, e - eq);
                if (!path)
                        return log_oom();
 
                uint64_t bytes;
                if (streq(bandwidth, "infinity"))
                        bytes = CGROUP_LIMIT_MAX;
                else {
                        r = parse_size(bandwidth, 1000, &bytes);
                        if (r < 0)
                                return parse_log_error(r, field, eq);
                }
 
                r = sd_bus_message_append(m, "(sv)", field, "a(st)", 1, path, bytes);
        }
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_parse_io_device_weight(sd_bus_message *m, const char *field, const char *eq) {
        int r;
 
        if (isempty(eq))
                r = sd_bus_message_append(m, "(sv)", field, "a(st)", 0);
        else {
                const char *e = strchr(eq, ' ');
                if (!e)
                        return parse_log_error(0, field, eq);
 
                const char *weight = e + 1;
                _cleanup_free_ char *path = strndup(eq, e - eq);
                if (!path)
                        return log_oom();
 
                uint64_t u;
                r = safe_atou64(weight, &u);
                if (r < 0)
                        return parse_log_error(r, field, weight);
 
                r = sd_bus_message_append(m, "(sv)", field, "a(st)", 1, path, u);
        }
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_parse_io_device_latency(sd_bus_message *m, const char *field, const char *eq) {
        const char *field_usec = "IODeviceLatencyTargetUSec";
        int r;
 
        if (isempty(eq))
                r = sd_bus_message_append(m, "(sv)", field_usec, "a(st)", 0);
        else {
                const char *e = strchr(eq, ' ');
                if (!e)
                        return parse_log_error(0, field, eq);
 
                const char *target = e + 1;
                _cleanup_free_ char *path = strndup(eq, e - eq);
                if (!path)
                        return log_oom();
 
                usec_t usec;
                r = parse_sec(target, &usec);
                if (r < 0)
                        return parse_log_error(r, field, target);
 
                r = sd_bus_message_append(m, "(sv)", field_usec, "a(st)", 1, path, usec);
        }
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_bpf_program(sd_bus_message *m, const char *field, const char *eq) {
        int r;
 
        if (isempty(eq))
                r = sd_bus_message_append(m, "(sv)", field, "a(ss)", 0);
        else {
                _cleanup_free_ char *word = NULL;
 
                r = extract_first_word(&eq, &word, ":", 0);
                if (r < 0)
                        return parse_log_error(r, field, eq);
 
                r = sd_bus_message_append(m, "(sv)", field, "a(ss)", 1, word, eq);
        }
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_socket_filter(sd_bus_message *m, const char *field, const char *eq) {
        int r;
 
        if (isempty(eq))
                r = sd_bus_message_append(m, "(sv)", field, "a(iiqq)", 0);
        else {
                int32_t family, ip_protocol;
                uint16_t nr_ports, port_min;
 
                r = parse_socket_bind_item(eq, &family, &ip_protocol, &nr_ports, &port_min);
                if (r < 0)
                        return parse_log_error(r, field, eq);
 
                r = sd_bus_message_append(
                                m, "(sv)", field, "a(iiqq)", 1, family, ip_protocol, nr_ports, port_min);
        }
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_exec_command(sd_bus_message *m, const char *field, const char *eq) {
        bool explicit_path = false, done = false, ambient_hack = false;
        _cleanup_strv_free_ char **cmdline = NULL, **ex_opts = NULL;
        _cleanup_free_ char *_path = NULL;
        ExecCommandFlags flags = 0;
        int r;
 
        assert(m);
        assert(field);
        assert(eq);
 
        do {
                switch (*eq) {
 
                case '-':
                        if (FLAGS_SET(flags, EXEC_COMMAND_IGNORE_FAILURE))
                                done = true;
                        else {
                                flags |= EXEC_COMMAND_IGNORE_FAILURE;
                                eq++;
                        }
                        break;
 
                case '@':
                        if (explicit_path)
                                done = true;
                        else {
                                explicit_path = true;
                                eq++;
                        }
                        break;
 
                case ':':
                        if (FLAGS_SET(flags, EXEC_COMMAND_NO_ENV_EXPAND))
                                done = true;
                        else {
                                flags |= EXEC_COMMAND_NO_ENV_EXPAND;
                                eq++;
                        }
                        break;
 
                case '+':
                        if ((flags & (EXEC_COMMAND_FULLY_PRIVILEGED|EXEC_COMMAND_NO_SETUID)) != 0 || ambient_hack)
                                done = true;
                        else {
                                flags |= EXEC_COMMAND_FULLY_PRIVILEGED;
                                eq++;
                        }
                        break;
 
                case '!':
                        if (FLAGS_SET(flags, EXEC_COMMAND_FULLY_PRIVILEGED) || ambient_hack)
                                done = true;
                        else if (FLAGS_SET(flags, EXEC_COMMAND_NO_SETUID)) {
                                /* Compatibility with the old !! ambient caps hack (removed in v258). Since
                                 * we don't support that anymore and !! was a noop on non-supporting systems,
                                 * we'll just turn off the EXEC_COMMAND_NO_SETUID flag again and be done with
                                 * it. */
                                flags &= ~EXEC_COMMAND_NO_SETUID;
                                eq++;
                                ambient_hack = true;
 
                                log_notice("!! modifier for %s= fields is no longer supported and is now ignored.", field);
                        } else {
                                flags |= EXEC_COMMAND_NO_SETUID;
                                eq++;
                        }
                        break;
 
                case '|':
                        if (FLAGS_SET(flags, EXEC_COMMAND_VIA_SHELL))
                                done = true;
                        else {
                                flags |= EXEC_COMMAND_VIA_SHELL;
                                eq++;
                        }
                        break;
 
                default:
                        done = true;
                }
        } while (!done);
 
        bool ex_prop = flags & (EXEC_COMMAND_NO_ENV_EXPAND|EXEC_COMMAND_FULLY_PRIVILEGED|EXEC_COMMAND_NO_SETUID|EXEC_COMMAND_VIA_SHELL);
        if (ex_prop) {
                /* We need to use ExecXYZEx=. */
                if (!endswith(field, "Ex"))
                        field = strjoina(field, "Ex");
 
                r = exec_command_flags_to_strv(flags, &ex_opts);
                if (r < 0)
                        return log_error_errno(r, "Failed to serialize ExecCommand flags: %m");
        } else {
                if (endswith(field, "Ex"))
                        field = strndupa_safe(field, strlen(field) - 2);
        }
 
        const char *path = NULL;
        if (FLAGS_SET(flags, EXEC_COMMAND_VIA_SHELL))
                path = _PATH_BSHELL;
        else if (explicit_path) {
                r = extract_first_word(&eq, &_path, NULL, EXTRACT_UNQUOTE|EXTRACT_CUNESCAPE);
                if (r < 0)
                        return parse_log_error(r, field, eq);
                if (r == 0)
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "No executable path specified for %s=, refusing.", field);
                if (isempty(eq))
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Got empty command line for %s=, refusing.", field);
                path = _path;
        }
 
        r = strv_split_full(&cmdline, eq, NULL, EXTRACT_UNQUOTE|EXTRACT_CUNESCAPE);
        if (r < 0)
                return parse_log_error(r, field, eq);
 
        if (FLAGS_SET(flags, EXEC_COMMAND_VIA_SHELL)) {
                r = strv_prepend(&cmdline, explicit_path ? "-sh" : "sh");
                if (r < 0)
                        return log_oom();
        }
 
        r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, field);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_open_container(m, 'v', ex_prop ? "a(sasas)" : "a(sasb)");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_open_container(m, 'a', ex_prop ? "(sasas)" : "(sasb)");
        if (r < 0)
                return bus_log_create_error(r);
 
        if (!strv_isempty(cmdline)) {
                r = sd_bus_message_open_container(m, 'r', ex_prop ? "sasas" : "sasb");
                if (r < 0)
                        return bus_log_create_error(r);
 
                r = sd_bus_message_append(m, "s", path ?: cmdline[0]);
                if (r < 0)
                        return bus_log_create_error(r);
 
                r = sd_bus_message_append_strv(m, cmdline);
                if (r < 0)
                        return bus_log_create_error(r);
 
                r = ex_prop ? sd_bus_message_append_strv(m, ex_opts) :
                              sd_bus_message_append(m, "b", FLAGS_SET(flags, EXEC_COMMAND_IGNORE_FAILURE));
                if (r < 0)
                        return bus_log_create_error(r);
 
                r = sd_bus_message_close_container(m);
                if (r < 0)
                        return bus_log_create_error(r);
        }
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_open_file(sd_bus_message *m, const char *field, const char *eq) {
        _cleanup_(open_file_freep) OpenFile *of = NULL;
        int r;
 
        assert(m);
 
        r = open_file_parse(eq, &of);
        if (r < 0)
                return parse_log_error(r, field, eq);
 
        r = sd_bus_message_append(m, "(sv)", field, "a(sst)", (size_t) 1, of->path, of->fdname, of->flags);
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_ip_address_access(sd_bus_message *m, int family, const union in_addr_union *prefix, unsigned char prefixlen) {
        int r;
 
        assert(m);
        assert(prefix);
 
        r = sd_bus_message_open_container(m, 'r', "iayu");
        if (r < 0)
                return r;
 
        r = sd_bus_message_append(m, "i", family);
        if (r < 0)
                return r;
 
        r = sd_bus_message_append_array(m, 'y', prefix, FAMILY_ADDRESS_SIZE(family));
        if (r < 0)
                return r;
 
        r = sd_bus_message_append(m, "u", prefixlen);
        if (r < 0)
                return r;
 
        return sd_bus_message_close_container(m);
}
 
static int bus_append_parse_ip_address_filter(sd_bus_message *m, const char *field, const char *eq) {
        union in_addr_union prefix = {};
        unsigned char prefixlen;
        int family, r;
 
        if (isempty(eq)) {
                r = sd_bus_message_append(m, "(sv)", field, "a(iayu)", 0);
                if (r < 0)
                        return bus_log_create_error(r);
 
                return 1;
        }
 
        r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, field);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_open_container(m, 'v', "a(iayu)");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_open_container(m, 'a', "(iayu)");
        if (r < 0)
                return bus_log_create_error(r);
 
        if (streq(eq, "any")) {
                /* "any" is a shortcut for 0.0.0.0/0 and ::/0 */
 
                r = bus_append_ip_address_access(m, AF_INET, &prefix, 0);
                if (r < 0)
                        return bus_log_create_error(r);
 
                r = bus_append_ip_address_access(m, AF_INET6, &prefix, 0);
                if (r < 0)
                        return bus_log_create_error(r);
 
        } else if (is_localhost(eq)) {
                /* "localhost" is a shortcut for 127.0.0.0/8 and ::1/128 */
 
                prefix.in.s_addr = htobe32(0x7f000000);
                r = bus_append_ip_address_access(m, AF_INET, &prefix, 8);
                if (r < 0)
                        return bus_log_create_error(r);
 
                prefix.in6 = (struct in6_addr) IN6ADDR_LOOPBACK_INIT;
                r = bus_append_ip_address_access(m, AF_INET6, &prefix, 128);
                if (r < 0)
                        return r;
 
        } else if (streq(eq, "link-local")) {
                /* "link-local" is a shortcut for 169.254.0.0/16 and fe80::/64 */
 
                prefix.in.s_addr = htobe32((UINT32_C(169) << 24 | UINT32_C(254) << 16));
                r = bus_append_ip_address_access(m, AF_INET, &prefix, 16);
                if (r < 0)
                        return bus_log_create_error(r);
 
                prefix.in6 = (struct in6_addr) {
                        .s6_addr32[0] = htobe32(0xfe800000)
                };
                r = bus_append_ip_address_access(m, AF_INET6, &prefix, 64);
                if (r < 0)
                        return bus_log_create_error(r);
 
        } else if (streq(eq, "multicast")) {
                /* "multicast" is a shortcut for 224.0.0.0/4 and ff00::/8 */
 
                prefix.in.s_addr = htobe32((UINT32_C(224) << 24));
                r = bus_append_ip_address_access(m, AF_INET, &prefix, 4);
                if (r < 0)
                        return bus_log_create_error(r);
 
                prefix.in6 = (struct in6_addr) {
                        .s6_addr32[0] = htobe32(0xff000000)
                };
                r = bus_append_ip_address_access(m, AF_INET6, &prefix, 8);
                if (r < 0)
                        return bus_log_create_error(r);
 
        } else
                for (;;) {
                        _cleanup_free_ char *word = NULL;
 
                        r = extract_first_word(&eq, &word, NULL, 0);
                        if (r < 0)
                                return parse_log_error(r, field, eq);
                        if (r == 0)
                                break;
 
                        r = in_addr_prefix_from_string_auto(word, &family, &prefix, &prefixlen);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse IP address prefix '%s': %m", word);
 
                        r = bus_append_ip_address_access(m, family, &prefix, prefixlen);
                        if (r < 0)
                                return bus_log_create_error(r);
                }
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
#define bus_append_trivial_array(m, field, eq, types, ...)              \
        ({                                                              \
                int r;                                                  \
                                                                        \
                if (isempty(eq))                                        \
                        r = sd_bus_message_append(m, "(sv)", field, types, 0); \
                else                                                    \
                        r = sd_bus_message_append(m, "(sv)", field, types, 1, __VA_ARGS__); \
                r < 0 ? bus_log_create_error(r) : 1;                    \
        })
 
static int bus_append_ip_filter_path(sd_bus_message *m, const char *field, const char *eq) {
        return bus_append_trivial_array(m, field, eq,
                                        "as", eq);
}
 
static int bus_append_nft_set(sd_bus_message *m, const char *field, const char *eq) {
        int r;
 
        assert(m);
        assert(field);
        assert(eq);
 
        if (isempty(eq)) {
                r = sd_bus_message_append(m, "(sv)", field, "a(iiss)", 0);
                if (r < 0)
                        return bus_log_create_error(r);
 
                return 1;
        }
 
        r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
        if (r < 0)
                return bus_log_create_error(r);