HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/core/dbus-execute.c

193,499 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 4d86c07a41a43be36f83303ea24907c57169829b

Lines 1–1000 of 4,331

/* SPDX-License-Identifier: LGPL-2.1-or-later */
 
#include <syslog.h>
#include <sys/mount.h>
#include <unistd.h>
 
#include "af-list.h"
#include "alloc-util.h"
#include "bpf-restrict-fs.h"
#include "bus-get-properties.h"
#include "bus-unit-util.h"
#include "capability-list.h"
#include "cpu-set-util.h"
#include "creds-util.h"
#include "dbus-execute.h"
#include "dbus-util.h"
#include "dissect-image.h"
#include "env-util.h"
#include "escape.h"
#include "exec-credential.h"
#include "execute.h"
#include "fd-util.h"
#include "hexdecoct.h"
#include "hostname-util.h"
#include "image-policy.h"
#include "ioprio-util.h"
#include "iovec-util.h"
#include "journal-file.h"
#include "memstream-util.h"
#include "mountpoint-util.h"
#include "namespace.h"
#include "nsflags.h"
#include "ordered-set.h"
#include "parse-util.h"
#include "path-util.h"
#include "percent-util.h"
#include "pcre2-util.h"
#include "process-util.h"
#include "rlimit-util.h"
#include "seccomp-util.h"
#include "securebits-util.h"
#include "set.h"
#include "specifier.h"
#include "strv.h"
#include "syslog-util.h"
#include "unit.h"
#include "user-util.h"
#include "utf8.h"
 
BUS_DEFINE_PROPERTY_GET_ENUM(bus_property_get_exec_output, exec_output, ExecOutput);
static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_exec_input, exec_input, ExecInput);
static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_exec_utmp_mode, exec_utmp_mode, ExecUtmpMode);
BUS_DEFINE_PROPERTY_GET_ENUM(bus_property_get_exec_preserve_mode, exec_preserve_mode, ExecPreserveMode);
static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_exec_keyring_mode, exec_keyring_mode, ExecKeyringMode);
static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_protect_proc, protect_proc, ProtectProc);
static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_proc_subset, proc_subset, ProcSubset);
static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_private_bpf, private_bpf, PrivateBPF);
static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_protect_home, protect_home, ProtectHome);
static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_protect_system, protect_system, ProtectSystem);
static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_personality, personality, unsigned long);
static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_exec_memory_thp, exec_memory_thp, ExecMemoryTHP);
static BUS_DEFINE_PROPERTY_GET(property_get_ioprio, "i", ExecContext, exec_context_get_effective_ioprio);
static BUS_DEFINE_PROPERTY_GET(property_get_mount_apivfs, "b", ExecContext, exec_context_get_effective_mount_apivfs);
static BUS_DEFINE_PROPERTY_GET(property_get_bind_log_sockets, "b", ExecContext, exec_context_get_effective_bind_log_sockets);
static BUS_DEFINE_PROPERTY_GET2(property_get_ioprio_class, "i", ExecContext, exec_context_get_effective_ioprio, ioprio_prio_class);
static BUS_DEFINE_PROPERTY_GET2(property_get_ioprio_priority, "i", ExecContext, exec_context_get_effective_ioprio, ioprio_prio_data);
static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_empty_string, "s", NULL);
static BUS_DEFINE_PROPERTY_GET_REF(property_get_private_tmp_ex, "s", PrivateTmp, private_tmp_to_string);
static BUS_DEFINE_PROPERTY_GET_REF(property_get_private_users_ex, "s", PrivateUsers, private_users_to_string);
static BUS_DEFINE_PROPERTY_GET_REF(property_get_protect_control_groups_ex, "s", ProtectControlGroups, protect_control_groups_to_string);
static BUS_DEFINE_PROPERTY_GET_REF(property_get_private_pids, "s", PrivatePIDs, private_pids_to_string);
static BUS_DEFINE_PROPERTY_GET_REF(property_get_syslog_level, "i", int, LOG_PRI);
static BUS_DEFINE_PROPERTY_GET_REF(property_get_syslog_facility, "i", int, LOG_FAC);
static BUS_DEFINE_PROPERTY_GET(property_get_cpu_affinity_from_numa, "b", ExecContext, exec_context_get_cpu_affinity_from_numa);
static BUS_DEFINE_PROPERTY_GET(property_get_oom_score_adjust, "i", ExecContext, exec_context_get_oom_score_adjust);
static BUS_DEFINE_PROPERTY_GET(property_get_nice, "i", ExecContext, exec_context_get_nice);
static BUS_DEFINE_PROPERTY_GET(property_get_cpu_sched_policy, "i", ExecContext, exec_context_get_cpu_sched_policy);
static BUS_DEFINE_PROPERTY_GET(property_get_cpu_sched_priority, "i", ExecContext, exec_context_get_cpu_sched_priority);
static BUS_DEFINE_PROPERTY_GET(property_get_coredump_filter, "t", ExecContext, exec_context_get_coredump_filter);
static BUS_DEFINE_PROPERTY_GET(property_get_timer_slack_nsec, "t", ExecContext, exec_context_get_timer_slack_nsec);
static BUS_DEFINE_PROPERTY_GET(property_get_set_login_environment, "b", ExecContext, exec_context_get_set_login_environment);
 
static int property_get_environment_files(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
        int r;
 
        assert(bus);
        assert(reply);
 
        r = sd_bus_message_open_container(reply, 'a', "(sb)");
        if (r < 0)
                return r;
 
        STRV_FOREACH(j, c->environment_files) {
                const char *fn = *j;
 
                r = sd_bus_message_append(reply, "(sb)", fn[0] == '-' ? fn + 1 : fn, fn[0] == '-');
                if (r < 0)
                        return r;
        }
 
        return sd_bus_message_close_container(reply);
}
 
static int property_get_cpu_affinity(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
        _cleanup_(cpu_set_done) CPUSet s = {};
        _cleanup_free_ uint8_t *array = NULL;
        size_t allocated;
        int r;
 
        assert(bus);
        assert(reply);
 
        if (c->cpu_affinity_from_numa) {
                r = numa_to_cpu_set(&c->numa_policy, &s);
                if (r < 0)
                        return r;
        }
 
        r = cpu_set_to_dbus(c->cpu_affinity_from_numa ? &s : &c->cpu_set, &array, &allocated);
        if (r < 0)
                return r;
 
        return sd_bus_message_append_array(reply, 'y', array, allocated);
}
 
static int property_get_numa_mask(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
        _cleanup_free_ uint8_t *array = NULL;
        size_t allocated;
 
        assert(bus);
        assert(reply);
 
        (void) cpu_set_to_dbus(&c->numa_policy.nodes, &array, &allocated);
 
        return sd_bus_message_append_array(reply, 'y', array, allocated);
}
 
static int property_get_numa_policy(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
        ExecContext *c = ASSERT_PTR(userdata);
        int32_t policy;
 
        assert(bus);
        assert(reply);
 
        policy = numa_policy_get_type(&c->numa_policy);
 
        return sd_bus_message_append_basic(reply, 'i', &policy);
}
 
static int property_get_syscall_filter(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
        _cleanup_strv_free_ char **l = NULL;
        int r;
 
        assert(bus);
        assert(reply);
 
        r = sd_bus_message_open_container(reply, 'r', "bas");
        if (r < 0)
                return r;
 
        r = sd_bus_message_append(reply, "b", c->syscall_allow_list);
        if (r < 0)
                return r;
 
        l = exec_context_get_syscall_filter(c);
        if (!l)
                return -ENOMEM;
 
        r = sd_bus_message_append_strv(reply, l);
        if (r < 0)
                return r;
 
        return sd_bus_message_close_container(reply);
}
 
static int property_get_syscall_log(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
        _cleanup_strv_free_ char **l = NULL;
        int r;
 
        assert(bus);
        assert(reply);
 
        r = sd_bus_message_open_container(reply, 'r', "bas");
        if (r < 0)
                return r;
 
        r = sd_bus_message_append(reply, "b", c->syscall_log_allow_list);
        if (r < 0)
                return r;
 
        l = exec_context_get_syscall_log(c);
        if (!l)
                return -ENOMEM;
 
        r = sd_bus_message_append_strv(reply, l);
        if (r < 0)
                return r;
 
        return sd_bus_message_close_container(reply);
}
 
static int property_get_syscall_archs(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
        _cleanup_strv_free_ char **l = NULL;
        int r;
 
        assert(bus);
        assert(reply);
 
        l = exec_context_get_syscall_archs(c);
        if (!l)
                return -ENOMEM;
 
        r = sd_bus_message_append_strv(reply, l);
        if (r < 0)
                return r;
 
        return 0;
}
 
static int property_get_selinux_context(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
 
        assert(bus);
        assert(reply);
 
        return sd_bus_message_append(reply, "(bs)", c->selinux_context_ignore, c->selinux_context);
}
 
static int property_get_apparmor_profile(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
 
        assert(bus);
        assert(reply);
 
        return sd_bus_message_append(reply, "(bs)", c->apparmor_profile_ignore, c->apparmor_profile);
}
 
static int property_get_smack_process_label(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
 
        assert(bus);
        assert(reply);
 
        return sd_bus_message_append(reply, "(bs)", c->smack_process_label_ignore, c->smack_process_label);
}
 
static int property_get_address_families(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
        _cleanup_strv_free_ char **l = NULL;
        int r;
 
        assert(bus);
        assert(reply);
 
        r = sd_bus_message_open_container(reply, 'r', "bas");
        if (r < 0)
                return r;
 
        r = sd_bus_message_append(reply, "b", c->address_families_allow_list);
        if (r < 0)
                return r;
 
        l = exec_context_get_address_families(c);
        if (!l)
                return -ENOMEM;
 
        r = sd_bus_message_append_strv(reply, l);
        if (r < 0)
                return r;
 
        return sd_bus_message_close_container(reply);
}
 
static int property_get_working_directory(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
        const char *wd;
 
        assert(bus);
        assert(reply);
 
        if (c->working_directory_home)
                wd = "~";
        else
                wd = c->working_directory;
 
        if (c->working_directory_missing_ok)
                wd = strjoina("!", wd);
 
        return sd_bus_message_append(reply, "s", wd);
}
 
static int property_get_stdio_fdname(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
        int fileno;
 
        assert(bus);
        assert(property);
        assert(reply);
 
        if (streq(property, "StandardInputFileDescriptorName"))
                fileno = STDIN_FILENO;
        else if (streq(property, "StandardOutputFileDescriptorName"))
                fileno = STDOUT_FILENO;
        else {
                assert(streq(property, "StandardErrorFileDescriptorName"));
                fileno = STDERR_FILENO;
        }
 
        return sd_bus_message_append(reply, "s", exec_context_fdname(c, fileno));
}
 
static int property_get_input_data(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
 
        assert(bus);
        assert(property);
        assert(reply);
 
        return sd_bus_message_append_array(reply, 'y', c->stdin_data, c->stdin_data_size);
}
 
static int property_get_restrict_filesystems(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
        _cleanup_free_ char **l = NULL; /* Strings are owned by 'c->restrict_filesystems'! */
        int r;
 
        assert(bus);
        assert(reply);
 
        r = sd_bus_message_open_container(reply, 'r', "bas");
        if (r < 0)
                return r;
 
        r = sd_bus_message_append(reply, "b", c->restrict_filesystems_allow_list);
        if (r < 0)
                return r;
 
        l = exec_context_get_restrict_filesystems(c);
        if (!l)
                return -ENOMEM;
 
        r = sd_bus_message_append_strv(reply, l);
        if (r < 0)
                return r;
 
        return sd_bus_message_close_container(reply);
}
 
static int property_get_bind_paths(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
        bool ro;
        int r;
 
        assert(bus);
        assert(property);
        assert(reply);
 
        ro = strstr(property, "ReadOnly");
 
        r = sd_bus_message_open_container(reply, 'a', "(ssbt)");
        if (r < 0)
                return r;
 
        FOREACH_ARRAY(i, c->bind_mounts, c->n_bind_mounts) {
                if (ro != i->read_only)
                        continue;
 
                r = sd_bus_message_append(
                                reply, "(ssbt)",
                                i->source,
                                i->destination,
                                i->ignore_enoent,
                                i->recursive ? (uint64_t) MS_REC : UINT64_C(0));
                if (r < 0)
                        return r;
        }
 
        return sd_bus_message_close_container(reply);
}
 
static int property_get_temporary_filesystems(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
        int r;
 
        assert(bus);
        assert(property);
        assert(reply);
 
        r = sd_bus_message_open_container(reply, 'a', "(ss)");
        if (r < 0)
                return r;
 
        FOREACH_ARRAY(t, c->temporary_filesystems, c->n_temporary_filesystems) {
                r = sd_bus_message_append(
                                reply, "(ss)",
                                t->path,
                                t->options);
                if (r < 0)
                        return r;
        }
 
        return sd_bus_message_close_container(reply);
}
 
static int property_get_log_extra_fields(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
        int r;
 
        assert(bus);
        assert(property);
        assert(reply);
 
        r = sd_bus_message_open_container(reply, 'a', "ay");
        if (r < 0)
                return r;
 
        FOREACH_ARRAY(i, c->log_extra_fields, c->n_log_extra_fields) {
                r = sd_bus_message_append_array(reply, 'y', i->iov_base, i->iov_len);
                if (r < 0)
                        return r;
        }
 
        return sd_bus_message_close_container(reply);
}
 
static int sd_bus_message_append_log_filter_patterns(sd_bus_message *reply, Set *patterns, bool is_allowlist) {
        const char *pattern;
        int r;
 
        assert(reply);
 
        SET_FOREACH(pattern, patterns) {
                r = sd_bus_message_append(reply, "(bs)", is_allowlist, pattern);
                if (r < 0)
                        return r;
        }
 
        return 0;
}
 
static int property_get_log_filter_patterns(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = userdata;
        int r;
 
        assert(c);
        assert(reply);
 
        r = sd_bus_message_open_container(reply, 'a', "(bs)");
        if (r < 0)
                return r;
 
        r = sd_bus_message_append_log_filter_patterns(reply, c->log_filter_allowed_patterns,
                                                      /* is_allowlist= */ true);
        if (r < 0)
                return r;
 
        r = sd_bus_message_append_log_filter_patterns(reply, c->log_filter_denied_patterns,
                                                      /* is_allowlist= */ false);
        if (r < 0)
                return r;
 
        return sd_bus_message_close_container(reply);
}
 
static int property_get_set_credential(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
        ExecSetCredential *sc;
        int r;
 
        assert(bus);
        assert(property);
        assert(reply);
 
        r = sd_bus_message_open_container(reply, 'a', "(say)");
        if (r < 0)
                return r;
 
        HASHMAP_FOREACH(sc, c->set_credentials) {
 
                if (sc->encrypted != streq(property, "SetCredentialEncrypted"))
                        continue;
 
                r = sd_bus_message_open_container(reply, 'r', "say");
                if (r < 0)
                        return r;
 
                r = sd_bus_message_append(reply, "s", sc->id);
                if (r < 0)
                        return r;
 
                r = sd_bus_message_append_array(reply, 'y', sc->data, sc->size);
                if (r < 0)
                        return r;
 
                r = sd_bus_message_close_container(reply);
                if (r < 0)
                        return r;
        }
 
        return sd_bus_message_close_container(reply);
}
 
static int property_get_load_credential(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
        ExecLoadCredential *lc;
        int r;
 
        assert(bus);
        assert(property);
        assert(reply);
 
        r = sd_bus_message_open_container(reply, 'a', "(ss)");
        if (r < 0)
                return r;
 
        HASHMAP_FOREACH(lc, c->load_credentials) {
 
                if (lc->encrypted != streq(property, "LoadCredentialEncrypted"))
                        continue;
 
                r = sd_bus_message_append(reply, "(ss)", lc->id, lc->path);
                if (r < 0)
                        return r;
        }
 
        return sd_bus_message_close_container(reply);
}
 
static int property_get_import_credential(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
        ExecImportCredential *ic;
        int r;
 
        assert(bus);
        assert(property);
        assert(reply);
 
        r = sd_bus_message_open_container(reply, 'a', "s");
        if (r < 0)
                return r;
 
        ORDERED_SET_FOREACH(ic, c->import_credentials) {
                r = sd_bus_message_append(reply, "s", ic->glob);
                if (r < 0)
                        return r;
        }
 
        return sd_bus_message_close_container(reply);
}
 
static int property_get_import_credential_ex(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
        ExecImportCredential *ic;
        int r;
 
        assert(bus);
        assert(property);
        assert(reply);
 
        r = sd_bus_message_open_container(reply, 'a', "(ss)");
        if (r < 0)
                return r;
 
        ORDERED_SET_FOREACH(ic, c->import_credentials) {
                r = sd_bus_message_append(reply, "(ss)", ic->glob, ic->rename);
                if (r < 0)
                        return r;
        }
 
        return sd_bus_message_close_container(reply);
}
 
static int property_get_root_hash(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
 
        assert(bus);
        assert(property);
        assert(reply);
 
        return sd_bus_message_append_array(reply, 'y', c->root_hash.iov_base, c->root_hash.iov_len);
}
 
static int property_get_root_hash_sig(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
 
        assert(bus);
        assert(property);
        assert(reply);
 
        return sd_bus_message_append_array(reply, 'y', c->root_hash_sig.iov_base, c->root_hash_sig.iov_len);
}
 
static int bus_append_mount_options(
                sd_bus_message *reply,
                const MountOptions *options) {
 
        int r;
 
        assert(reply);
 
        r = sd_bus_message_open_container(reply, 'a', "(ss)");
        if (r < 0)
                return r;
 
        if (options)
                for (PartitionDesignator i = 0; i < _PARTITION_DESIGNATOR_MAX; i++) {
                        if (isempty(options->options[i]))
                                continue;
 
                        r = sd_bus_message_append(reply, "(ss)",
                                                  partition_designator_to_string(i),
                                                  options->options[i]);
                        if (r < 0)
                                return r;
                }
 
        return sd_bus_message_close_container(reply);
}
 
static int property_get_root_image_options(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
 
        assert(bus);
        assert(property);
        assert(reply);
 
        return bus_append_mount_options(reply, c->root_image_options);
}
 
static int property_get_mount_images(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
        int r;
 
        assert(bus);
        assert(property);
        assert(reply);
 
        r = sd_bus_message_open_container(reply, 'a', "(ssba(ss))");
        if (r < 0)
                return r;
 
        FOREACH_ARRAY(i, c->mount_images, c->n_mount_images) {
                r = sd_bus_message_open_container(reply, SD_BUS_TYPE_STRUCT, "ssba(ss)");
                if (r < 0)
                        return r;
 
                r = sd_bus_message_append(
                                reply, "ssb",
                                i->source,
                                i->destination,
                                i->ignore_enoent);
                if (r < 0)
                        return r;
 
                r = bus_append_mount_options(reply, i->mount_options);
                if (r < 0)
                        return r;
 
                r = sd_bus_message_close_container(reply);
                if (r < 0)
                        return r;
        }
 
        return sd_bus_message_close_container(reply);
}
 
static int property_get_extension_images(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecContext *c = ASSERT_PTR(userdata);
        int r;
 
        assert(bus);
        assert(property);
        assert(reply);
 
        r = sd_bus_message_open_container(reply, 'a', "(sba(ss))");
        if (r < 0)
                return r;
 
        FOREACH_ARRAY(i, c->extension_images, c->n_extension_images) {
                r = sd_bus_message_open_container(reply, SD_BUS_TYPE_STRUCT, "sba(ss)");
                if (r < 0)
                        return r;
 
                r = sd_bus_message_append(
                                reply, "sb",
                                i->source,
                                i->ignore_enoent);
                if (r < 0)
                        return r;
 
                r = bus_append_mount_options(reply, i->mount_options);
                if (r < 0)
                        return r;
 
                r = sd_bus_message_close_container(reply);
                if (r < 0)
                        return r;
        }
 
        return sd_bus_message_close_container(reply);
}
 
static int property_get_exec_dir(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecDirectory *d = ASSERT_PTR(userdata);
        int r;
 
        assert(bus);
        assert(property);
        assert(reply);
 
        r = sd_bus_message_open_container(reply, 'a', "s");
        if (r < 0)
                return r;
 
        FOREACH_ARRAY(i, d->items, d->n_items) {
                r = sd_bus_message_append_basic(reply, 's', i->path);
                if (r < 0)
                        return r;
        }
 
        return sd_bus_message_close_container(reply);
}
 
static int property_get_exec_dir_symlink(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        ExecDirectory *d = ASSERT_PTR(userdata);
        int r;
 
        assert(bus);
        assert(property);
        assert(reply);
 
        r = sd_bus_message_open_container(reply, 'a', "(sst)");
        if (r < 0)
                return r;
 
        FOREACH_ARRAY(i, d->items, d->n_items)
                if (strv_isempty(i->symlinks)) {
                        /* The old exec directory properties cannot represent flags, so list them here with no
                         * destination */
                        r = sd_bus_message_append(reply, "(sst)", i->path, "", (uint64_t) (i->flags & _EXEC_DIRECTORY_FLAGS_PUBLIC));
                        if (r < 0)
                                return r;
                } else
                        STRV_FOREACH(dst, i->symlinks) {
                                r = sd_bus_message_append(reply, "(sst)", i->path, *dst, (uint64_t) (i->flags & _EXEC_DIRECTORY_FLAGS_PUBLIC));
                                if (r < 0)
                                        return r;
                        }
 
        return sd_bus_message_close_container(reply);
}
 
static int property_get_exec_quota(sd_bus *bus,
                const char *path,
                const char *interface,