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 2001–3000 of 4,331

        }
 
        if (streq(name, "RootVerity"))
                return bus_set_transient_path(u, name, &c->root_verity, message, flags, reterr_error);
 
        if (streq(name, "RootDirectory"))
                return bus_set_transient_path(u, name, &c->root_directory, message, flags, reterr_error);
 
        if (streq(name, "RootEphemeral"))
                return bus_set_transient_bool(u, name, &c->root_ephemeral, message, flags, reterr_error);
 
        if (streq(name, "SyslogIdentifier"))
                return bus_set_transient_string(u, name, &c->syslog_identifier, message, flags, reterr_error);
 
        if (streq(name, "LogLevelMax"))
                return bus_set_transient_log_level(u, name, &c->log_level_max, message, flags, reterr_error);
 
        if (streq(name, "LogRateLimitIntervalUSec"))
                return bus_set_transient_usec(u, name, &c->log_ratelimit.interval, message, flags, reterr_error);
 
        if (streq(name, "LogRateLimitBurst"))
                return bus_set_transient_unsigned(u, name, &c->log_ratelimit.burst, message, flags, reterr_error);
 
        if (streq(name, "LogFilterPatterns")) {
                /* Use _cleanup_free_, not _cleanup_strv_free_, as we don't want the content of the strv
                 * to be freed. */
                _cleanup_free_ char **allow_list = NULL, **deny_list = NULL;
                const char *pattern;
                int is_allowlist;
 
                r = sd_bus_message_enter_container(message, 'a', "(bs)");
                if (r < 0)
                        return r;
 
                while ((r = sd_bus_message_read(message, "(bs)", &is_allowlist, &pattern)) > 0) {
                        _cleanup_(pcre2_code_freep) pcre2_code *compiled_pattern = NULL;
 
                        if (isempty(pattern))
                                continue;
 
                        r = pattern_compile_and_log(pattern, 0, &compiled_pattern);
                        if (r < 0)
                                return r;
 
                        r = strv_push(is_allowlist ? &allow_list : &deny_list, (char *)pattern);
                        if (r < 0)
                                return r;
                }
                if (r < 0)
                        return r;
 
                r = sd_bus_message_exit_container(message);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        if (strv_isempty(allow_list) && strv_isempty(deny_list)) {
                                c->log_filter_allowed_patterns = set_free(c->log_filter_allowed_patterns);
                                c->log_filter_denied_patterns = set_free(c->log_filter_denied_patterns);
                                unit_write_settingf(u, flags, name, "%s=", name);
                        } else {
                                r = set_put_strdupv(&c->log_filter_allowed_patterns, allow_list);
                                if (r < 0)
                                        return r;
                                r = set_put_strdupv(&c->log_filter_denied_patterns, deny_list);
                                if (r < 0)
                                        return r;
 
                                STRV_FOREACH(unit_pattern, allow_list)
                                        unit_write_settingf(u, flags, name, "%s=%s", name, *unit_pattern);
                                STRV_FOREACH(unit_pattern, deny_list)
                                        unit_write_settingf(u, flags, name, "%s=~%s", name, *unit_pattern);
                        }
                }
 
                return 1;
        }
 
        if (streq(name, "Personality"))
                return bus_set_transient_personality(u, name, &c->personality, message, flags, reterr_error);
 
        if (streq(name, "StandardInput"))
                return bus_set_transient_std_input(u, name, &c->std_input, message, flags, reterr_error);
 
        if (streq(name, "StandardOutput"))
                return bus_set_transient_std_output(u, name, &c->std_output, message, flags, reterr_error);
 
        if (streq(name, "StandardError"))
                return bus_set_transient_std_output(u, name, &c->std_error, message, flags, reterr_error);
 
        if (streq(name, "IgnoreSIGPIPE"))
                return bus_set_transient_bool(u, name, &c->ignore_sigpipe, message, flags, reterr_error);
 
        if (streq(name, "TTYVHangup"))
                return bus_set_transient_bool(u, name, &c->tty_vhangup, message, flags, reterr_error);
 
        if (streq(name, "TTYReset"))
                return bus_set_transient_bool(u, name, &c->tty_reset, message, flags, reterr_error);
 
        if (streq(name, "TTYVTDisallocate"))
                return bus_set_transient_bool(u, name, &c->tty_vt_disallocate, message, flags, reterr_error);
 
        if (streq(name, "TTYRows"))
                return bus_set_transient_unsigned(u, name, &c->tty_rows, message, flags, reterr_error);
 
        if (streq(name, "TTYColumns"))
                return bus_set_transient_unsigned(u, name, &c->tty_cols, message, flags, reterr_error);
 
        if (streq(name, "PrivateTmp")) {
                int v;
 
                r = sd_bus_message_read(message, "b", &v);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        c->private_tmp = v ? PRIVATE_TMP_CONNECTED : PRIVATE_TMP_NO;
                        (void) unit_write_settingf(u, flags, name, "%s=%s", name, yes_no(v));
                }
 
                return 1;
 
        } else if (streq(name, "PrivateTmpEx")) {
                const char *s;
                PrivateTmp t;
 
                r = sd_bus_message_read(message, "s", &s);
                if (r < 0)
                        return r;
 
                t = private_tmp_from_string(s);
                if (t < 0)
                        return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Invalid %s setting: %s", name, s);
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        c->private_tmp = t;
                        (void) unit_write_settingf(u, flags, name, "PrivateTmp=%s",
                                                   private_tmp_to_string(c->private_tmp));
                }
 
                return 1;
        }
 
        if (streq(name, "PrivateUsers")) {
                int v;
 
                r = sd_bus_message_read(message, "b", &v);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        c->private_users = v ? PRIVATE_USERS_SELF : PRIVATE_USERS_NO;
                        (void) unit_write_settingf(u, flags, name, "%s=%s", name, yes_no(v));
                }
 
                return 1;
 
        } else if (streq(name, "PrivateUsersEx")) {
                const char *s;
                PrivateUsers t;
 
                r = sd_bus_message_read(message, "s", &s);
                if (r < 0)
                        return r;
 
                t = private_users_from_string(s);
                if (t < 0)
                        return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Invalid %s setting: %s", name, s);
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        c->private_users = t;
                        (void) unit_write_settingf(u, flags, name, "PrivateUsers=%s",
                                                   private_users_to_string(c->private_users));
                }
 
                return 1;
        }
 
        if (streq(name, "ProtectControlGroups")) {
                int v;
 
                r = sd_bus_message_read(message, "b", &v);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        c->protect_control_groups = v ? PROTECT_CONTROL_GROUPS_YES : PROTECT_CONTROL_GROUPS_NO;
                        (void) unit_write_settingf(u, flags, name, "%s=%s", name, yes_no(v));
                }
 
                return 1;
        }
 
        if (streq(name, "ProtectControlGroupsEx")) {
                const char *s;
                ProtectControlGroups t;
 
                r = sd_bus_message_read(message, "s", &s);
                if (r < 0)
                        return r;
 
                t = protect_control_groups_from_string(s);
                if (t < 0)
                        return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Invalid %s setting: %s", name, s);
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        c->protect_control_groups = t;
                        (void) unit_write_settingf(u, flags, name, "ProtectControlGroups=%s",
                                                   protect_control_groups_to_string(c->protect_control_groups));
                }
 
                return 1;
        }
 
        if (streq(name, "PrivatePIDs")) {
                const char *s;
                PrivatePIDs t;
 
                r = sd_bus_message_read(message, "s", &s);
                if (r < 0)
                        return r;
 
                t = private_pids_from_string(s);
                if (t < 0)
                        return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Invalid %s setting: %s", name, s);
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        c->private_pids = t;
                        (void) unit_write_settingf(u, flags, name, "%s=%s",
                                                   name, private_pids_to_string(c->private_pids));
                }
 
                return 1;
        }
 
        if (streq(name, "ProtectHostname")) {
                int v;
 
                r = sd_bus_message_read(message, "b", &v);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        c->protect_hostname = v ? PROTECT_HOSTNAME_YES : PROTECT_HOSTNAME_NO;
                        (void) unit_write_settingf(u, flags, name, "%s=%s", name, yes_no(v));
                }
 
                return 1;
 
        }
 
        if (streq(name, "ProtectHostnameEx")) {
                const char *s, *h = NULL;
 
                r = sd_bus_message_read(message, "(ss)", &s, &h);
                if (r < 0)
                        return r;
 
                if (!isempty(h) && !hostname_is_valid(h, /* flags= */ 0))
                        return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Invalid hostname in %s setting: %s", name, h);
 
                ProtectHostname t = protect_hostname_from_string(s);
                if (t < 0 || (t == PROTECT_HOSTNAME_NO && !isempty(h)))
                        return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Invalid %s setting: %s", name, s);
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        c->protect_hostname = t;
                        r = free_and_strdup(&c->private_hostname, empty_to_null(h));
                        if (r < 0)
                                return r;
 
                        (void) unit_write_settingf(u, flags, name, "ProtectHostname=%s%s%s",
                                                   protect_hostname_to_string(c->protect_hostname),
                                                   c->private_hostname ? ":" : "",
                                                   strempty(c->private_hostname));
                }
 
                return 1;
        }
 
        if (streq(name, "PrivateDevices"))
                return bus_set_transient_bool(u, name, &c->private_devices, message, flags, reterr_error);
 
        if (streq(name, "PrivateMounts"))
                return bus_set_transient_tristate(u, name, &c->private_mounts, message, flags, reterr_error);
 
        if (streq(name, "MountAPIVFS"))
                return bus_set_transient_tristate(u, name, &c->mount_apivfs, message, flags, reterr_error);
 
        if (streq(name, "BindLogSockets"))
                return bus_set_transient_tristate(u, name, &c->bind_log_sockets, message, flags, reterr_error);
 
        if (streq(name, "PrivateNetwork"))
                return bus_set_transient_bool(u, name, &c->private_network, message, flags, reterr_error);
 
        if (streq(name, "PrivateIPC"))
                return bus_set_transient_bool(u, name, &c->private_ipc, message, flags, reterr_error);
 
        if (streq(name, "NoNewPrivileges"))
                return bus_set_transient_bool(u, name, &c->no_new_privileges, message, flags, reterr_error);
 
        if (streq(name, "SyslogLevelPrefix"))
                return bus_set_transient_bool(u, name, &c->syslog_level_prefix, message, flags, reterr_error);
 
        if (streq(name, "MemoryDenyWriteExecute"))
                return bus_set_transient_bool(u, name, &c->memory_deny_write_execute, message, flags, reterr_error);
 
        if (streq(name, "RestrictRealtime"))
                return bus_set_transient_bool(u, name, &c->restrict_realtime, message, flags, reterr_error);
 
        if (streq(name, "RestrictSUIDSGID"))
                return bus_set_transient_bool(u, name, &c->restrict_suid_sgid, message, flags, reterr_error);
 
        if (streq(name, "DynamicUser"))
                return bus_set_transient_bool(u, name, &c->dynamic_user, message, flags, reterr_error);
 
        if (streq(name, "RemoveIPC"))
                return bus_set_transient_bool(u, name, &c->remove_ipc, message, flags, reterr_error);
 
        if (streq(name, "ProtectKernelTunables"))
                return bus_set_transient_bool(u, name, &c->protect_kernel_tunables, message, flags, reterr_error);
 
        if (streq(name, "ProtectKernelModules"))
                return bus_set_transient_bool(u, name, &c->protect_kernel_modules, message, flags, reterr_error);
 
        if (streq(name, "ProtectKernelLogs"))
                return bus_set_transient_bool(u, name, &c->protect_kernel_logs, message, flags, reterr_error);
 
        if (streq(name, "ProtectClock"))
                return bus_set_transient_bool(u, name, &c->protect_clock, message, flags, reterr_error);
 
        if (streq(name, "CPUSchedulingResetOnFork"))
                return bus_set_transient_bool(u, name, &c->cpu_sched_reset_on_fork, message, flags, reterr_error);
 
        if (streq(name, "NonBlocking"))
                return bus_set_transient_bool(u, name, &c->non_blocking, message, flags, reterr_error);
 
        if (streq(name, "LockPersonality"))
                return bus_set_transient_bool(u, name, &c->lock_personality, message, flags, reterr_error);
 
        if (streq(name, "MemoryKSM"))
                return bus_set_transient_tristate(u, name, &c->memory_ksm, message, flags, reterr_error);
 
        if (streq(name, "MemoryTHP"))
                return bus_set_transient_exec_memory_thp(u, name, &c->memory_thp, message, flags, reterr_error);
 
        if (streq(name, "UtmpIdentifier"))
                return bus_set_transient_string(u, name, &c->utmp_id, message, flags, reterr_error);
 
        if (streq(name, "UtmpMode"))
                return bus_set_transient_utmp_mode(u, name, &c->utmp_mode, message, flags, reterr_error);
 
        if (streq(name, "PAMName"))
                return bus_set_transient_string(u, name, &c->pam_name, message, flags, reterr_error);
 
        if (streq(name, "TimerSlackNSec"))
                return bus_set_transient_nsec(u, name, &c->timer_slack_nsec, message, flags, reterr_error);
 
        if (streq(name, "ProtectSystem"))
                return bus_set_transient_protect_system(u, name, &c->protect_system, message, flags, reterr_error);
 
        if (streq(name, "ProtectHome"))
                return bus_set_transient_protect_home(u, name, &c->protect_home, message, flags, reterr_error);
 
        if (streq(name, "KeyringMode"))
                return bus_set_transient_keyring_mode(u, name, &c->keyring_mode, message, flags, reterr_error);
 
        if (streq(name, "ProtectProc"))
                return bus_set_transient_protect_proc(u, name, &c->protect_proc, message, flags, reterr_error);
 
        if (streq(name, "ProcSubset"))
                return bus_set_transient_proc_subset(u, name, &c->proc_subset, message, flags, reterr_error);
 
        if (streq(name, "PrivateBPF"))
                return bus_set_transient_private_bpf(u, name, &c->private_bpf, message, flags, reterr_error);
 
        if (streq(name, "BPFDelegateCommands"))
                return bus_set_transient_bpf_delegate_commands(u, name, &c->bpf_delegate_commands, message, flags, reterr_error);
 
        if (streq(name, "BPFDelegateMaps"))
                return bus_set_transient_bpf_delegate_maps(u, name, &c->bpf_delegate_maps, message, flags, reterr_error);
 
        if (streq(name, "BPFDelegatePrograms"))
                return bus_set_transient_bpf_delegate_programs(u, name, &c->bpf_delegate_programs, message, flags, reterr_error);
 
        if (streq(name, "BPFDelegateAttachments"))
                return bus_set_transient_bpf_delegate_attachments(u, name, &c->bpf_delegate_attachments, message, flags, reterr_error);
 
        if (streq(name, "RuntimeDirectoryPreserve"))
                return bus_set_transient_exec_preserve_mode(u, name, &c->runtime_directory_preserve_mode, message, flags, reterr_error);
 
        if (streq(name, "UMask"))
                return bus_set_transient_mode_t(u, name, &c->umask, message, flags, reterr_error);
 
        if (streq(name, "RuntimeDirectoryMode"))
                return bus_set_transient_mode_t(u, name, &c->directories[EXEC_DIRECTORY_RUNTIME].mode, message, flags, reterr_error);
 
        if (streq(name, "StateDirectoryAccounting"))
                return bus_set_transient_bool(u, name, &c->directories[EXEC_DIRECTORY_STATE].exec_quota.quota_accounting, message, flags, reterr_error);
 
        if (streq(name, "CacheDirectoryAccounting"))
                return bus_set_transient_bool(u, name, &c->directories[EXEC_DIRECTORY_CACHE].exec_quota.quota_accounting, message, flags, reterr_error);
 
        if (streq(name, "LogsDirectoryAccounting"))
                return bus_set_transient_bool(u, name, &c->directories[EXEC_DIRECTORY_LOGS].exec_quota.quota_accounting, message, flags, reterr_error);
 
        if (streq(name, "StateDirectoryMode"))
                return bus_set_transient_mode_t(u, name, &c->directories[EXEC_DIRECTORY_STATE].mode, message, flags, reterr_error);
 
        if (streq(name, "CacheDirectoryMode"))
                return bus_set_transient_mode_t(u, name, &c->directories[EXEC_DIRECTORY_CACHE].mode, message, flags, reterr_error);
 
        if (streq(name, "LogsDirectoryMode"))
                return bus_set_transient_mode_t(u, name, &c->directories[EXEC_DIRECTORY_LOGS].mode, message, flags, reterr_error);
 
        if (streq(name, "ConfigurationDirectoryMode"))
                return bus_set_transient_mode_t(u, name, &c->directories[EXEC_DIRECTORY_CONFIGURATION].mode, message, flags, reterr_error);
 
        if (streq(name, "SELinuxContext"))
                return bus_set_transient_string(u, name, &c->selinux_context, message, flags, reterr_error);
 
        if (streq(name, "SecureBits"))
                return bus_set_transient_secure_bits(u, name, &c->secure_bits, message, flags, reterr_error);
 
        if (streq(name, "CapabilityBoundingSet"))
                return bus_set_transient_capability(u, name, &c->capability_bounding_set, message, flags, reterr_error);
 
        if (streq(name, "AmbientCapabilities"))
                return bus_set_transient_capability(u, name, &c->capability_ambient_set, message, flags, reterr_error);
 
        if (streq(name, "RestrictNamespaces"))
                return bus_set_transient_namespace_flag(u, name, &c->restrict_namespaces, message, flags, reterr_error);
 
        if (streq(name, "DelegateNamespaces"))
                return bus_set_transient_namespace_flag(u, name, &c->delegate_namespaces, message, flags, reterr_error);
 
        if (streq(name, "RestrictFileSystems")) {
                int allow_list;
                _cleanup_strv_free_ char **l = NULL;
 
                r = sd_bus_message_enter_container(message, 'r', "bas");
                if (r < 0)
                        return r;
 
                r = sd_bus_message_read(message, "b", &allow_list);
                if (r < 0)
                        return r;
 
                r = sd_bus_message_read_strv(message, &l);
                if (r < 0)
                        return r;
 
                r = sd_bus_message_exit_container(message);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        _cleanup_free_ char *joined = NULL;
                        FilesystemParseFlags invert_flag = allow_list ? 0 : FILESYSTEM_PARSE_INVERT;
 
                        if (strv_isempty(l)) {
                                c->restrict_filesystems_allow_list = false;
                                c->restrict_filesystems = set_free(c->restrict_filesystems);
 
                                unit_write_setting(u, flags, name, "RestrictFileSystems=");
                                return 1;
                        }
 
                        if (!c->restrict_filesystems)
                                c->restrict_filesystems_allow_list = allow_list;
 
                        STRV_FOREACH(s, l) {
                                r = bpf_restrict_fs_parse_filesystem(
                                              *s,
                                              &c->restrict_filesystems,
                                              FILESYSTEM_PARSE_LOG|
                                              (invert_flag ? FILESYSTEM_PARSE_INVERT : 0)|
                                              (c->restrict_filesystems_allow_list ? FILESYSTEM_PARSE_ALLOW_LIST : 0),
                                              u->id, NULL, 0);
                                if (r < 0)
                                        return r;
                        }
 
                        joined = strv_join(l, " ");
                        if (!joined)
                                return -ENOMEM;
 
                        unit_write_settingf(u, flags, name, "%s=%s%s", name, allow_list ? "" : "~", joined);
                }
 
                return 1;
        }
 
        if (streq(name, "MountFlags"))
                return bus_set_transient_mount_propagation_flag(u, name, &c->mount_propagation_flag, message, flags, reterr_error);
 
        if (streq(name, "NetworkNamespacePath"))
                return bus_set_transient_path(u, name, &c->network_namespace_path, message, flags, reterr_error);
 
        if (streq(name, "UserNamespacePath"))
                return bus_set_transient_path(u, name, &c->user_namespace_path, message, flags, reterr_error);
 
        if (streq(name, "IPCNamespacePath"))
                return bus_set_transient_path(u, name, &c->ipc_namespace_path, message, flags, reterr_error);
 
        if (streq(name, "SupplementaryGroups")) {
                _cleanup_strv_free_ char **l = NULL;
 
                r = sd_bus_message_read_strv(message, &l);
                if (r < 0)
                        return r;
 
                STRV_FOREACH(p, l)
                        if (!isempty(*p) && !valid_user_group_name(*p, VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX|VALID_USER_WARN))
                                return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS,
                                                        "Invalid supplementary group names");
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        if (strv_isempty(l)) {
                                c->supplementary_groups = strv_free(c->supplementary_groups);
                                unit_write_settingf(u, flags, name, "%s=", name);
                        } else {
                                _cleanup_free_ char *joined = NULL;
 
                                r = strv_extend_strv(&c->supplementary_groups, l, true);
                                if (r < 0)
                                        return r;
 
                                joined = strv_join(c->supplementary_groups, " ");
                                if (!joined)
                                        return -ENOMEM;
 
                                unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "%s=%s", name, joined);
                        }
                }
 
                return 1;
 
        } else if (STR_IN_SET(name, "SetCredential", "SetCredentialEncrypted")) {
                bool encrypted = endswith(name, "Encrypted");
                bool isempty = true;
 
                r = sd_bus_message_enter_container(message, 'a', "(say)");
                if (r < 0)
                        return r;
 
                for (;;) {
                        const char *id;
                        const void *p;
                        size_t sz;
                        const char *err = NULL;
 
                        r = sd_bus_message_enter_container(message, 'r', "say");
                        if (r < 0)
                                return r;
                        if (r == 0)
                                break;
 
                        r = sd_bus_message_read(message, "s", &id);
                        if (r < 0)
                                return r;
 
                        r = sd_bus_message_read_array(message, 'y', &p, &sz);
                        if (r < 0)
                                return r;
 
                        r = sd_bus_message_exit_container(message);
                        if (r < 0)
                                return r;
 
                        isempty = false;
 
                        r = exec_context_apply_set_credential(u, c, id, p, sz, encrypted, flags, &err);
                        if (r == -EINVAL)
                                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "%s: %s", err, id);
                        if (r < 0)
                                return r;
                }
 
                r = sd_bus_message_exit_container(message);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags) && isempty) {
                        c->set_credentials = hashmap_free(c->set_credentials);
                        (void) unit_write_settingf(u, flags, name, "%s=", name);
                }
 
                return 1;
 
        } else if (STR_IN_SET(name, "LoadCredential", "LoadCredentialEncrypted")) {
                bool isempty = true;
 
                r = sd_bus_message_enter_container(message, 'a', "(ss)");
                if (r < 0)
                        return r;
 
                for (;;) {
                        const char *id, *source;
 
                        r = sd_bus_message_read(message, "(ss)", &id, &source);
                        if (r < 0)
                                return r;
                        if (r == 0)
                                break;
 
                        if (!credential_name_valid(id))
                                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Credential ID is invalid: %s", id);
 
                        if (!(path_is_absolute(source) ? path_is_normalized(source) : credential_name_valid(source)))
                                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Credential source is invalid: %s", source);
 
                        isempty = false;
 
                        if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                                bool encrypted = endswith(name, "Encrypted");
 
                                r = exec_context_put_load_credential(c, id, source, encrypted);
                                if (r < 0)
                                        return r;
 
                                (void) unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "%s=%s:%s", name, id, source);
                        }
                }
 
                r = sd_bus_message_exit_container(message);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags) && isempty) {
                        c->load_credentials = hashmap_free(c->load_credentials);
                        (void) unit_write_settingf(u, flags, name, "%s=", name);
                }
 
                return 1;
 
        } else if (STR_IN_SET(name, "ImportCredential", "ImportCredentialEx")) {
                bool empty = true, ex = streq(name, "ImportCredentialEx");
 
                r = sd_bus_message_enter_container(message, 'a', ex ? "(ss)" : "s");
                if (r < 0)
                        return r;
 
                for (;;) {
                        const char *glob, *rename = NULL;
 
                        if (ex)
                                r = sd_bus_message_read(message, "(ss)", &glob, &rename);
                        else
                                r = sd_bus_message_read(message, "s", &glob);
                        if (r < 0)
                                return r;
                        if (r == 0)
                                break;
 
                        if (!credential_glob_valid(glob))
                                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Credential name or glob is invalid: %s", glob);
 
                        rename = empty_to_null(rename);
 
                        if (rename && !credential_name_valid(rename))
                                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Credential name is invalid: %s", rename);
 
                        empty = false;
 
                        if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                                r = exec_context_put_import_credential(c, glob, rename);
                                if (r < 0)
                                        return r;
 
                                (void) unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name,
                                                           "ImportCredential=%s%s%s",
                                                           glob, rename ? ":" : "", strempty(rename));
                        }
                }
 
                r = sd_bus_message_exit_container(message);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags) && empty) {
                        c->import_credentials = ordered_set_free(c->import_credentials);
                        (void) unit_write_settingf(u, flags, name, "%s=", name);
                }
 
                return 1;
 
        } else if (streq(name, "SyslogLevel")) {
                int32_t level;
 
                r = sd_bus_message_read(message, "i", &level);
                if (r < 0)
                        return r;
 
                if (!log_level_is_valid(level))
                        return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Log level value out of range");
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        c->syslog_priority = (c->syslog_priority & LOG_FACMASK) | level;
                        unit_write_settingf(u, flags, name, "SyslogLevel=%i", level);
                }
 
                return 1;
 
        } else if (streq(name, "SyslogFacility")) {
                int32_t facility;
 
                r = sd_bus_message_read(message, "i", &facility);
                if (r < 0)
                        return r;
 
                if (!log_facility_unshifted_is_valid(facility))
                        return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Log facility value out of range");
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        c->syslog_priority = (facility << 3) | LOG_PRI(c->syslog_priority);
                        unit_write_settingf(u, flags, name, "SyslogFacility=%i", facility);
                }
 
                return 1;
 
        } else if (streq(name, "LogNamespace")) {
                const char *n;
 
                r = sd_bus_message_read(message, "s", &n);
                if (r < 0)
                        return r;
 
                if (!isempty(n) && !log_namespace_name_valid(n))
                        return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Log namespace name not valid");
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
 
                        if (isempty(n)) {
                                c->log_namespace = mfree(c->log_namespace);
                                unit_write_settingf(u, flags, name, "%s=", name);
                        } else {
                                r = free_and_strdup(&c->log_namespace, n);
                                if (r < 0)
                                        return r;
 
                                unit_write_settingf(u, flags, name, "%s=%s", name, n);
                        }
                }
 
                return 1;
 
        } else if (streq(name, "LogExtraFields")) {
                size_t n = 0;
 
                r = sd_bus_message_enter_container(message, 'a', "ay");
                if (r < 0)
                        return r;
 
                for (;;) {
                        _cleanup_free_ void *copy = NULL;
                        const char *eq;
                        const void *p;
                        size_t sz;
 
                        /* Note that we expect a byte array for each field, instead of a string. That's because on the
                         * lower-level journal fields can actually contain binary data and are not restricted to text,
                         * and we should not "lose precision" in our types on the way. That said, I am pretty sure
                         * actually encoding binary data as unit metadata is not a good idea. Hence we actually refuse
                         * any actual binary data, and only accept UTF-8. This allows us to eventually lift this
                         * limitation, should a good, valid use case arise. */
 
                        r = sd_bus_message_read_array(message, 'y', &p, &sz);
                        if (r < 0)
                                return r;
                        if (r == 0)
                                break;
 
                        if (memchr(p, 0, sz))
                                return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Journal field contains zero byte");
 
                        eq = memchr(p, '=', sz);
                        if (!eq)
                                return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Journal field contains no '=' character");
                        if (!journal_field_valid(p, eq - (const char*) p, false))
                                return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Journal field invalid");
 
                        copy = memdup_suffix0(p, sz);
                        if (!copy)
                                return -ENOMEM;
 
                        if (!utf8_is_valid(copy))
                                return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Journal field is not valid UTF-8");
 
                        if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                                if (c->n_log_extra_fields >= LOG_EXTRA_FIELDS_MAX)
                                        return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Too many extra log fields.");
 
                                if (!GREEDY_REALLOC(c->log_extra_fields, c->n_log_extra_fields + 1))
                                        return -ENOMEM;
 
                                c->log_extra_fields[c->n_log_extra_fields++] = IOVEC_MAKE(copy, sz);
                                unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS|UNIT_ESCAPE_C, name, "LogExtraFields=%s", (char*) copy);
                                TAKE_PTR(copy);
                        }
 
                        n++;
                }
 
                r = sd_bus_message_exit_container(message);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags) && n == 0) {
                        exec_context_free_log_extra_fields(c);
                        unit_write_setting(u, flags, name, "LogExtraFields=");
                }
 
                return 1;
        }
 
#if HAVE_SECCOMP
 
        if (streq(name, "SystemCallErrorNumber"))
                return bus_set_transient_errno(u, name, &c->syscall_errno, message, flags, reterr_error);
 
        if (streq(name, "SystemCallFilter")) {
                int allow_list;
                _cleanup_strv_free_ char **l = NULL;
 
                r = sd_bus_message_enter_container(message, 'r', "bas");
                if (r < 0)
                        return r;
 
                r = sd_bus_message_read(message, "b", &allow_list);
                if (r < 0)
                        return r;
 
                r = sd_bus_message_read_strv(message, &l);
                if (r < 0)
                        return r;
 
                r = sd_bus_message_exit_container(message);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        _cleanup_free_ char *joined = NULL;
                        SeccompParseFlags invert_flag = allow_list ? 0 : SECCOMP_PARSE_INVERT;
 
                        if (strv_isempty(l)) {
                                c->syscall_allow_list = false;
                                c->syscall_filter = hashmap_free(c->syscall_filter);
 
                                unit_write_settingf(u, flags, name, "SystemCallFilter=");
                                return 1;
                        }
 
                        if (!c->syscall_filter) {
                                c->syscall_filter = hashmap_new(NULL);
                                if (!c->syscall_filter)
                                        return log_oom();
 
                                c->syscall_allow_list = allow_list;
 
                                if (c->syscall_allow_list) {
                                        r = seccomp_parse_syscall_filter("@default",
                                                                         -1,
                                                                         c->syscall_filter,
                                                                         SECCOMP_PARSE_PERMISSIVE |
                                                                         SECCOMP_PARSE_ALLOW_LIST,
                                                                         u->id,
                                                                         NULL, 0);
                                        if (r < 0)
                                                return r;
                                }
                        }
 
                        STRV_FOREACH(s, l) {
                                _cleanup_free_ char *n = NULL;
                                int e;
 
                                r = parse_syscall_and_errno(*s, &n, &e);
                                if (r < 0)
                                        return r;
 
                                if (allow_list && e >= 0)
                                        return -EINVAL;
 
                                r = seccomp_parse_syscall_filter(n,
                                                                 e,
                                                                 c->syscall_filter,
                                                                 SECCOMP_PARSE_LOG | SECCOMP_PARSE_PERMISSIVE |
                                                                 invert_flag |
                                                                 (c->syscall_allow_list ? SECCOMP_PARSE_ALLOW_LIST : 0),
                                                                 u->id,
                                                                 NULL, 0);
                                if (r < 0)
                                        return r;
                        }
 
                        joined = strv_join(l, " ");
                        if (!joined)
                                return -ENOMEM;
 
                        unit_write_settingf(u, flags, name, "SystemCallFilter=%s%s", allow_list ? "" : "~", joined);
                }
 
                return 1;
 
        } else if (streq(name, "SystemCallLog")) {
                int allow_list;
                _cleanup_strv_free_ char **l = NULL;
 
                r = sd_bus_message_enter_container(message, 'r', "bas");
                if (r < 0)
                        return r;
 
                r = sd_bus_message_read(message, "b", &allow_list);
                if (r < 0)
                        return r;
 
                r = sd_bus_message_read_strv(message, &l);
                if (r < 0)
                        return r;
 
                r = sd_bus_message_exit_container(message);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        _cleanup_free_ char *joined = NULL;
                        SeccompParseFlags invert_flag = allow_list ? 0 : SECCOMP_PARSE_INVERT;
 
                        if (strv_isempty(l)) {
                                c->syscall_log_allow_list = false;
                                c->syscall_log = hashmap_free(c->syscall_log);
 
                                unit_write_settingf(u, flags, name, "SystemCallLog=");
                                return 1;
                        }
 
                        if (!c->syscall_log) {
                                c->syscall_log = hashmap_new(NULL);
                                if (!c->syscall_log)
                                        return log_oom();
 
                                c->syscall_log_allow_list = allow_list;
                        }
 
                        STRV_FOREACH(s, l) {
                                r = seccomp_parse_syscall_filter(*s,
                                                                 -1, /* errno not used */
                                                                 c->syscall_log,
                                                                 SECCOMP_PARSE_LOG | SECCOMP_PARSE_PERMISSIVE |
                                                                 invert_flag |
                                                                 (c->syscall_log_allow_list ? SECCOMP_PARSE_ALLOW_LIST : 0),
                                                                 u->id,
                                                                 NULL, 0);
                                if (r < 0)
                                        return r;
                        }
 
                        joined = strv_join(l, " ");
                        if (!joined)
                                return -ENOMEM;
 
                        unit_write_settingf(u, flags, name, "SystemCallLog=%s%s", allow_list ? "" : "~", joined);
                }
 
                return 1;
 
        } else if (streq(name, "SystemCallArchitectures")) {
                _cleanup_strv_free_ char **l = NULL;
 
                r = sd_bus_message_read_strv(message, &l);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        _cleanup_free_ char *joined = NULL;
 
                        if (strv_isempty(l))
                                c->syscall_archs = set_free(c->syscall_archs);
                        else {
                                r = parse_syscall_archs(l, &c->syscall_archs);
                                if (r < 0)
                                        return r;
                        }
 
                        joined = strv_join(l, " ");
                        if (!joined)
                                return -ENOMEM;
 
                        unit_write_settingf(u, flags, name, "%s=%s", name, joined);
                }
 
                return 1;
 
        } else if (streq(name, "RestrictAddressFamilies")) {
                _cleanup_strv_free_ char **l = NULL;
                int allow_list;
 
                r = sd_bus_message_enter_container(message, 'r', "bas");
                if (r < 0)