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 1001–2000 of 3,301

 
        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(iiss)");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_open_container(m, 'a', "(iiss)");
        if (r < 0)
                return bus_log_create_error(r);
 
        for (const char *p = eq;;) {
                _cleanup_free_ char *tuple = NULL, *source_str = NULL, *nfproto_str = NULL, *table = NULL, *set = NULL;
                const char *q = NULL;
                int source, nfproto;
 
                r = extract_first_word(&p, &tuple, NULL, EXTRACT_UNQUOTE|EXTRACT_RETAIN_ESCAPE);
                if (r < 0)
                        return parse_log_error(r, field, eq);
                if (r == 0)
                        break;
                if (isempty(tuple))
                        return parse_log_error(0, field, eq);
 
                q = tuple;
                r = extract_many_words(&q, ":", EXTRACT_CUNESCAPE, &source_str, &nfproto_str, &table, &set);
                if (r != 4 || !isempty(q))
                        return parse_log_error(0, field, tuple);
 
                assert(source_str);
                assert(nfproto_str);
                assert(table);
                assert(set);
 
                source = r = nft_set_source_from_string(source_str);
                if (r < 0)
                        return log_error_errno(r, "Failed to parse NFT set source '%s': %m", source_str);
                if (!IN_SET(source, NFT_SET_SOURCE_CGROUP, NFT_SET_SOURCE_USER, NFT_SET_SOURCE_GROUP))
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Bad NFT set source value '%s'.",
                                               nft_set_source_to_string(source));
 
                nfproto = r = nfproto_from_string(nfproto_str);
                if (r < 0)
                        return log_error_errno(r, "Failed to parse nft protocol '%s': %m", nfproto_str);
 
                if (!nft_identifier_valid(table))
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Bad NFT identifier name '%s'.", table);
                if (!nft_identifier_valid(set))
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Bad NFT identifier name '%s'.", set);
 
                r = sd_bus_message_append(m, "(iiss)", source, nfproto, table, set);
                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_environment_files(sd_bus_message *m, const char *field, const char *eq) {
        return bus_append_trivial_array(m, "EnvironmentFiles", eq,
                                        "a(sb)",
                                        eq[0] == '-' ? eq + 1 : eq,
                                        eq[0] == '-');
}
 
static int bus_append_set_credential(sd_bus_message *m, const char *field, const char *eq) {
        int r;
 
        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(say)");
        if (r < 0)
                return bus_log_create_error(r);
 
        if (isempty(eq))
                r = sd_bus_message_append(m, "a(say)", 0);
        else {
                _cleanup_free_ char *word = NULL;
                const char *p = eq;
 
                r = extract_first_word(&p, &word, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
                if (r <= 0 || !p)
                        return parse_log_error(r < 0 ? r : 0, field, eq);
 
                r = sd_bus_message_open_container(m, 'a', "(say)");
                if (r < 0)
                        return bus_log_create_error(r);
 
                r = sd_bus_message_open_container(m, 'r', "say");
                if (r < 0)
                        return bus_log_create_error(r);
 
                r = sd_bus_message_append(m, "s", word);
                if (r < 0)
                        return bus_log_create_error(r);
 
                if (endswith(field, "Encrypted")) {
                        _cleanup_free_ void *decoded = NULL;
                        size_t decoded_size;
 
                        r = unbase64mem(p, &decoded, &decoded_size);
                        if (r < 0)
                                return log_error_errno(r, "Failed to decode base64 data for %s=: %m", field);
 
                        r = sd_bus_message_append_array(m, 'y', decoded, decoded_size);
                } else {
                        _cleanup_free_ char *unescaped = NULL;
                        ssize_t l;
 
                        l = cunescape(p, UNESCAPE_ACCEPT_NUL, &unescaped);
                        if (l < 0)
                                return log_error_errno(l, "Failed to unescape value for %s=: %s", field, p);
 
                        r = sd_bus_message_append_array(m, 'y', unescaped, l);
                }
                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_load_credential(sd_bus_message *m, const char *field, const char *eq) {
        int r;
 
        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);
 
        if (isempty(eq))
                r = sd_bus_message_append(m, "a(ss)", 0);
        else {
                _cleanup_free_ char *word = NULL;
                const char *p = eq;
 
                r = extract_first_word(&p, &word, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
                if (r <= 0)
                        return parse_log_error(r, field, eq);
 
                if (isempty(p)) /* If only one field is specified, then this means "inherit from above" */
                        p = eq;
 
                r = sd_bus_message_append(m, "a(ss)", 1, word, p);
        }
        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_import_credential(sd_bus_message *m, const char *field, const char *eq) {
        int r;
 
        if (isempty(eq))
                r = sd_bus_message_append(m, "(sv)", "ImportCredential", "as", 0);
        else {
                _cleanup_free_ char *word = NULL;
                const char *p = eq;
 
                r = extract_first_word(&p, &word, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
                if (r <= 0)
                        return parse_log_error(r, field, eq);
 
                if (!p)
                        r = sd_bus_message_append(m, "(sv)", "ImportCredential", "as", 1, eq);
                else {
                        /* We need to send ImportCredentialEx */
                        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', "ImportCredentialEx");
                        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_append(m, "a(ss)", 1, word, p);
                        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_refresh_on_reload(sd_bus_message *m, const char *field, const char *eq) {
        int r;
 
        assert(eq);
 
        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(bs)");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_open_container(m, 'a', "(bs)");
        if (r < 0)
                return bus_log_create_error(r);
 
        bool invert = *eq == '~';
 
        for (const char *p = eq + invert;;) {
                _cleanup_free_ char *word = NULL;
 
                r = extract_first_word(&p, &word, NULL, 0);
                if (r < 0)
                        return parse_log_error(r, field, eq);
                if (r == 0)
                        break;
 
                r = sd_bus_message_append(m, "(bs)", invert, 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_log_extra_fields(sd_bus_message *m, const char *field, const char *eq) {
        int r;
 
        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', "aay");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_open_container(m, 'a', "ay");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_append_array(m, 'y', eq, strlen(eq));
        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_log_filter_patterns(sd_bus_message *m, const char *field, const char *eq) {
        return bus_append_trivial_array(m, field, eq,
                                        "a(bs)",
                                        eq[0] != '~',
                                        eq[0] != '~' ? eq : eq + 1);
}
 
static int bus_append_standard_inputs(sd_bus_message *m, const char *field, const char *eq) {
        const char *n, *appended;
        int r;
 
        if ((n = startswith(eq, "fd:"))) {
                appended = strjoina(field, "FileDescriptorName");
                r = sd_bus_message_append(m, "(sv)", appended, "s", n);
        } else if ((n = startswith(eq, "file:"))) {
                appended = strjoina(field, "File");
                r = sd_bus_message_append(m, "(sv)", appended, "s", n);
        } else if ((n = startswith(eq, "append:"))) {
                appended = strjoina(field, "FileToAppend");
                r = sd_bus_message_append(m, "(sv)", appended, "s", n);
        } else if ((n = startswith(eq, "truncate:"))) {
                appended = strjoina(field, "FileToTruncate");
                r = sd_bus_message_append(m, "(sv)", appended, "s", n);
        } else
                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_standard_input_text(sd_bus_message *m, const char *field, const char *eq) {
        _cleanup_free_ char *unescaped = NULL;
        ssize_t l;
 
        l = cunescape(eq, 0, &unescaped);
        if (l < 0)
                return log_error_errno(l, "Failed to unescape value for %s=: %s", field, eq);
 
        if (!strextend(&unescaped, "\n"))
                return log_oom();
 
        /* Note that we don't expand specifiers here, but that should be OK, as this is a
         * programmatic interface anyway */
 
        /* The server side does not have StandardInputText, using StandardInputData instead. */
        return bus_append_byte_array(m, "StandardInputData", unescaped, l + 1);
}
 
static int bus_append_standard_input_data(sd_bus_message *m, const char *field, const char *eq) {
        _cleanup_free_ void *decoded = NULL;
        size_t sz;
        int r;
 
        r = unbase64mem(eq, &decoded, &sz);
        if (r < 0)
                return log_error_errno(r, "Failed to decode base64 data for %s=: %m", field);
 
        return bus_append_byte_array(m, field, decoded, sz);
}
 
static int bus_try_append_resource_limit(sd_bus_message *m, const char *field, const char *eq) {
        int r;
 
        const char *suffix = startswith(field, "Limit");
        if (!suffix)
                return 0;
 
        int rl = rlimit_from_string(suffix);
        if (rl < 0)
                return 0;  /* We let the generic error machinery handle this. */
 
        struct rlimit l;
        r = rlimit_parse(rl, eq, &l);
        if (r < 0)
                return parse_log_error(r, field, eq);
 
        r = sd_bus_message_append(m, "(sv)", field, "t", (uint64_t) l.rlim_max);
        if (r < 0)
                return bus_log_create_error(r);
 
        const char *sn = strjoina(field, "Soft");
        r = sd_bus_message_append(m, "(sv)", sn, "t", (uint64_t) l.rlim_cur);
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static void dump_resource_limits(void) {
        rlimits_list("Limit");
}
 
static int bus_append_string_with_ignore(sd_bus_message *m, const char *field, const char *eq) {
        int ignore = 0;
        const char *s = eq;
        int r;
 
        if (eq[0] == '-') {
                ignore = 1;
                s = eq + 1;
        }
 
        r = sd_bus_message_append(m, "(sv)", field, "(bs)", ignore, s);
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_capabilities(sd_bus_message *m, const char *field, const char *eq) {
        uint64_t sum = 0;
        bool invert = false;
        const char *p = eq;
        int r;
 
        if (*p == '~') {
                invert = true;
                p++;
        }
 
        r = capability_set_from_string(p, &sum);
        if (r < 0)
                return parse_log_error(r, field, eq);
 
        sum = invert ? ~sum : sum;
 
        r = sd_bus_message_append(m, "(sv)", field, "t", sum);
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_cpu_affinity(sd_bus_message *m, const char *field, const char *eq) {
        int r;
 
        if (streq_ptr(eq, "numa")) {
                r = sd_bus_message_append(m, "(sv)", "CPUAffinityFromNUMA", "b", true);
                if (r < 0)
                        return bus_log_create_error(r);
                return 1;
        }
 
        return bus_append_parse_cpu_set(m, field, eq);
}
 
static int bus_append_numa_mask(sd_bus_message *m, const char *field, const char *eq) {
        _cleanup_(cpu_set_done) CPUSet nodes = {};
        _cleanup_free_ uint8_t *array = NULL;
        size_t allocated;
        int r;
 
        if (eq && streq(eq, "all")) {
                r = numa_mask_add_all(&nodes);
                if (r < 0)
                        return log_error_errno(r, "Failed to create NUMA mask representing \"all\" NUMA nodes: %m");
        } else {
                r = parse_cpu_set(eq, &nodes);
                if (r < 0)
                        return parse_log_error(r, field, eq);
        }
 
        r = cpu_set_to_dbus(&nodes, &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_filter_list(sd_bus_message *m, const char *field, const char *eq) {
        int allow_list = 1;
        const char *p = eq;
        int r;
 
        if (*p == '~') {
                allow_list = 0;
                p++;
        }
 
        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', "(bas)");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_open_container(m, 'r', "bas");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_append_basic(m, 'b', &allow_list);
        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 (;;) {
                _cleanup_free_ char *word = NULL;
 
                r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
                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);
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_namespace_list(sd_bus_message *m, const char *field, const char *eq) {
        bool invert = false;
        unsigned long all = UPDATE_FLAG(NAMESPACE_FLAGS_ALL, CLONE_NEWUSER, !streq(field, "DelegateNamespaces"));
        unsigned long flags;
        int r;
 
        r = parse_boolean(eq);
        if (r > 0)
                /* RestrictNamespaces= value gets stored into a field with reverse semantics (the
                 * namespaces which are retained), so RestrictNamespaces=true means we retain no
                 * access to any namespaces and vice-versa. */
                flags = streq(field, "RestrictNamespaces") ? 0 : all;
        else if (r == 0)
                flags = streq(field, "RestrictNamespaces") ? all : 0;
        else {
                if (eq[0] == '~') {
                        invert = true;
                        eq++;
                }
 
                r = namespace_flags_from_string(eq, &flags);
                if (r < 0)
                        return parse_log_error(r, field, eq);
        }
 
        if (invert)
                flags = (~flags) & all;
 
        r = sd_bus_message_append(m, "(sv)", field, "t", (uint64_t) flags);
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_bind_paths(sd_bus_message *m, const char *field, const char *eq) {
        const char *p = eq;
        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', "a(ssbt)");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_open_container(m, 'a', "(ssbt)");
        if (r < 0)
                return bus_log_create_error(r);
 
        for (;;) {
                _cleanup_free_ char *source = NULL, *destination = NULL;
                char *s = NULL, *d = NULL;
                bool ignore_enoent = false;
                uint64_t flags = MS_REC;
 
                r = extract_first_word(&p, &source, ":" WHITESPACE, EXTRACT_UNQUOTE|EXTRACT_DONT_COALESCE_SEPARATORS);
                if (r < 0)
                        return parse_log_error(r, field, eq);
                if (r == 0)
                        break;
 
                s = source;
                if (s[0] == '-') {
                        ignore_enoent = true;
                        s++;
                }
 
                if (p && p[-1] == ':') {
                        r = extract_first_word(&p, &destination, ":" WHITESPACE, EXTRACT_UNQUOTE|EXTRACT_DONT_COALESCE_SEPARATORS);
                        if (r < 0)
                                return parse_log_error(r, field, p);
                        if (r == 0)
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Missing argument after ':': %s", eq);
 
                        d = destination;
 
                        if (p && p[-1] == ':') {
                                _cleanup_free_ char *options = NULL;
 
                                r = extract_first_word(&p, &options, NULL, EXTRACT_UNQUOTE);
                                if (r < 0)
                                        return parse_log_error(r, field, p);
 
                                if (isempty(options) || streq(options, "rbind"))
                                        flags = MS_REC;
                                else if (streq(options, "norbind"))
                                        flags = 0;
                                else
                                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                                               "Unknown options: %s", eq);
                        }
                } else
                        d = s;
 
                r = sd_bus_message_append(m, "(ssbt)", s, d, ignore_enoent, flags);
                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_temporary_file_system(sd_bus_message *m, const char *field, const char *eq) {
        const char *p = eq;
        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', "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);
 
        for (;;) {
                _cleanup_free_ char *word = NULL, *path = NULL;
                const char *w;
 
                r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
                if (r < 0)
                        return parse_log_error(r, field, eq);
                if (r == 0)
                        break;
 
                w = word;
                r = extract_first_word(&w, &path, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
                if (r <= 0)
                        return parse_log_error(r, field, eq);
 
                r = sd_bus_message_append(m, "(ss)", path, w);
                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_root_hash(sd_bus_message *m, const char *field, const char *eq) {
        _cleanup_free_ void *roothash_decoded = NULL;
        size_t roothash_decoded_size = 0;
        int r;
 
        /* We have the path to a roothash to load and decode, eg: RootHash=/foo/bar.roothash */
        if (path_is_absolute(eq))
                return bus_append_string(m, "RootHashPath", eq);
 
        /* We have a roothash to decode, eg: RootHash=012345789abcdef */
        r = unhexmem(eq, &roothash_decoded, &roothash_decoded_size);
        if (r < 0)
                return log_error_errno(r, "Failed to decode base64 data for %s=: %m", field);
        if (roothash_decoded_size < sizeof(sd_id128_t))
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "%s value '%s' is too short.", field, eq);
 
        return bus_append_byte_array(m, field, roothash_decoded, roothash_decoded_size);
}
 
static int bus_append_root_hash_signature(sd_bus_message *m, const char *field, const char *eq) {
        _cleanup_free_ void *roothash_sig_decoded = NULL;
        size_t roothash_sig_decoded_size = 0;
        int r;
 
        /* We have the path to a roothash signature to load and decode, eg: RootHash=/foo/bar.roothash.p7s */
        if (path_is_absolute(eq))
                return bus_append_string(m, "RootHashSignaturePath", eq);
 
        const char *value = startswith(eq, "base64:");
        if (!value)
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                       "Failed to decode %s value '%s': neither a path nor starts with 'base64:'.",
                                       field, eq);
 
        /* We have a roothash signature to decode, eg: RootHashSignature=base64:012345789abcdef */
        r = unbase64mem(value, &roothash_sig_decoded, &roothash_sig_decoded_size);
        if (r < 0)
                return log_error_errno(r, "Failed to decode base64 data for %s=: %m", field);
 
        return bus_append_byte_array(m, field, roothash_sig_decoded, roothash_sig_decoded_size);
}
 
static int bus_append_root_image_options(sd_bus_message *m, const char *field, const char *eq) {
        _cleanup_strv_free_ char **l = NULL;
        const char *p = eq;
        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', "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);
 
        r = strv_split_colon_pairs(&l, p);
        if (r < 0)
                return parse_log_error(r, field, eq);
 
        STRV_FOREACH_PAIR(first, second, l) {
                r = sd_bus_message_append(m, "(ss)",
                                          !isempty(*second) ? *first : "root",
                                          !isempty(*second) ? *second : *first);
                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_mount_images(sd_bus_message *m, const char *field, const char *eq) {
        const char *p = eq;
        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', "a(ssba(ss))");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_open_container(m, 'a', "(ssba(ss))");
        if (r < 0)
                return bus_log_create_error(r);
 
        for (;;) {
                _cleanup_free_ char *first = NULL, *second = NULL, *tuple = NULL;
                const char *q = NULL, *source = NULL;
                bool permissive = false;
 
                r = extract_first_word(&p, &tuple, NULL, EXTRACT_UNQUOTE|EXTRACT_RETAIN_ESCAPE);
                if (r < 0)
                        return parse_log_error(r, field, eq);
                if (r == 0)
                        break;
 
                q = tuple;
                r = extract_many_words(&q, ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS, &first, &second);
                if (r < 0)
                        return parse_log_error(r, field, eq);
                if (r == 0)
                        continue;
 
                source = first;
                if (source[0] == '-') {
                        permissive = true;
                        source++;
                }
 
                if (isempty(second))
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                               "Missing argument after ':' for %s=: '%s'", field, eq);
 
                r = sd_bus_message_open_container(m, 'r', "ssba(ss)");
                if (r < 0)
                        return bus_log_create_error(r);
 
                r = sd_bus_message_append(m, "ssb", source, second, permissive);
                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);
 
                for (;;) {
                        _cleanup_free_ char *partition = NULL, *mount_options = NULL;
 
                        r = extract_many_words(&q, ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS, &partition, &mount_options);
                        if (r < 0)
                                return parse_log_error(r, field, eq);
                        if (r == 0)
                                break;
                        /* Single set of options, applying to the root partition/single filesystem */
                        if (r == 1) {
                                r = sd_bus_message_append(m, "(ss)", "root", partition);
                                if (r < 0)
                                        return bus_log_create_error(r);
 
                                break;
                        }
 
                        r = sd_bus_message_append(m, "(ss)", partition, mount_options);
                        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);
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_extension_images(sd_bus_message *m, const char *field, const char *eq) {
        const char *p = eq;
        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', "a(sba(ss))");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_open_container(m, 'a', "(sba(ss))");
        if (r < 0)
                return bus_log_create_error(r);
 
        for (;;) {
                _cleanup_free_ char *source = NULL, *tuple = NULL;
                const char *q = NULL, *s = NULL;
                bool permissive = false;
 
                r = extract_first_word(&p, &tuple, NULL, EXTRACT_UNQUOTE|EXTRACT_RETAIN_ESCAPE);
                if (r < 0)
                        return parse_log_error(r, field, eq);
                if (r == 0)
                        break;
 
                q = tuple;
                r = extract_first_word(&q, &source, ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS);
                if (r < 0)
                        return parse_log_error(r, field, eq);
                if (r == 0)
                        continue;
 
                s = source;
                if (s[0] == '-') {
                        permissive = true;
                        s++;
                }
 
                r = sd_bus_message_open_container(m, 'r', "sba(ss)");
                if (r < 0)
                        return bus_log_create_error(r);
 
                r = sd_bus_message_append(m, "sb", s, permissive);
                if (r < 0)
                        return bus_log_create_error(r);
 
                r = sd_bus_message_open_container(m, 'a', "(ss)");
                if (r < 0)