[thirdparty/systemd.git] / src / core / dbus-service.c

/* SPDX-License-Identifier: LGPL-2.1+ */

#include <fcntl.h>

#include "alloc-util.h"
#include "async.h"
#include "bus-internal.h"
#include "bus-util.h"
#include "dbus-cgroup.h"
#include "dbus-execute.h"
#include "dbus-kill.h"
#include "dbus-manager.h"
#include "dbus-service.h"
#include "dbus-util.h"
#include "exit-status.h"
#include "fd-util.h"
#include "fileio.h"
#include "parse-util.h"
#include "path-util.h"
#include "service.h"
#include "signal-util.h"
#include "string-util.h"
#include "strv.h"
#include "unit.h"

static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_type, service_type, ServiceType);
static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_result, service_result, ServiceResult);
static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_restart, service_restart, ServiceRestart);
static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_notify_access, notify_access, NotifyAccess);
static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_emergency_action, emergency_action, EmergencyAction);
static BUS_DEFINE_PROPERTY_GET(property_get_timeout_abort_usec, "t", Service, service_timeout_abort_usec);

static int property_get_exit_status_set(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {

        ExitStatusSet *status_set = userdata;
        Iterator i;
        void *id;
        int r;

        assert(bus);
        assert(reply);
        assert(status_set);

        r = sd_bus_message_open_container(reply, 'r', "aiai");
        if (r < 0)
                return r;

        r = sd_bus_message_open_container(reply, 'a', "i");
        if (r < 0)
                return r;

        SET_FOREACH(id, status_set->status, i) {
                int32_t val = PTR_TO_INT(id);

                if (val < 0 || val > 255)
                        continue;

                r = sd_bus_message_append_basic(reply, 'i', &val);
                if (r < 0)
                        return r;
        }

        r = sd_bus_message_close_container(reply);
        if (r < 0)
                return r;

        r = sd_bus_message_open_container(reply, 'a', "i");
        if (r < 0)
                return r;

        SET_FOREACH(id, status_set->signal, i) {
                int32_t val = PTR_TO_INT(id);
                const char *str;

                str = signal_to_string((int) val);
                if (!str)
                        continue;

                r = sd_bus_message_append_basic(reply, 'i', &val);
                if (r < 0)
                        return r;
        }

        r = sd_bus_message_close_container(reply);
        if (r < 0)
                return r;

        return sd_bus_message_close_container(reply);
}

const sd_bus_vtable bus_service_vtable[] = {
        SD_BUS_VTABLE_START(0),
        SD_BUS_PROPERTY("Type", "s", property_get_type, offsetof(Service, type), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("Restart", "s", property_get_restart, offsetof(Service, restart), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("PIDFile", "s", NULL, offsetof(Service, pid_file), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("NotifyAccess", "s", property_get_notify_access, offsetof(Service, notify_access), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("RestartUSec", "t", bus_property_get_usec, offsetof(Service, restart_usec), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("TimeoutStartUSec", "t", bus_property_get_usec, offsetof(Service, timeout_start_usec), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("TimeoutStopUSec", "t", bus_property_get_usec, offsetof(Service, timeout_stop_usec), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("TimeoutAbortUSec", "t", property_get_timeout_abort_usec, 0, 0),
        SD_BUS_PROPERTY("RuntimeMaxUSec", "t", bus_property_get_usec, offsetof(Service, runtime_max_usec), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("WatchdogUSec", "t", bus_property_get_usec, offsetof(Service, watchdog_usec), SD_BUS_VTABLE_PROPERTY_CONST),
        BUS_PROPERTY_DUAL_TIMESTAMP("WatchdogTimestamp", offsetof(Service, watchdog_timestamp), 0),
        SD_BUS_PROPERTY("PermissionsStartOnly", "b", bus_property_get_bool, offsetof(Service, permissions_start_only), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN), /* 😷 deprecated */
        SD_BUS_PROPERTY("RootDirectoryStartOnly", "b", bus_property_get_bool, offsetof(Service, root_directory_start_only), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("RemainAfterExit", "b", bus_property_get_bool, offsetof(Service, remain_after_exit), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("GuessMainPID", "b", bus_property_get_bool, offsetof(Service, guess_main_pid), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("RestartPreventExitStatus", "(aiai)", property_get_exit_status_set, offsetof(Service, restart_prevent_status), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("RestartForceExitStatus", "(aiai)", property_get_exit_status_set, offsetof(Service, restart_force_status), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("SuccessExitStatus", "(aiai)", property_get_exit_status_set, offsetof(Service, success_status), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("MainPID", "u", bus_property_get_pid, offsetof(Service, main_pid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("ControlPID", "u", bus_property_get_pid, offsetof(Service, control_pid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("BusName", "s", NULL, offsetof(Service, bus_name), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("FileDescriptorStoreMax", "u", bus_property_get_unsigned, offsetof(Service, n_fd_store_max), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("NFileDescriptorStore", "u", bus_property_get_unsigned, offsetof(Service, n_fd_store), 0),
        SD_BUS_PROPERTY("StatusText", "s", NULL, offsetof(Service, status_text), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("StatusErrno", "i", bus_property_get_int, offsetof(Service, status_errno), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("Result", "s", property_get_result, offsetof(Service, result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("ReloadResult", "s", property_get_result, offsetof(Service, reload_result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("USBFunctionDescriptors", "s", NULL, offsetof(Service, usb_function_descriptors), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("USBFunctionStrings", "s", NULL, offsetof(Service, usb_function_strings), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("UID", "u", bus_property_get_uid, offsetof(Unit, ref_uid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("GID", "u", bus_property_get_gid, offsetof(Unit, ref_gid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("NRestarts", "u", bus_property_get_unsigned, offsetof(Service, n_restarts), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("OOMPolicy", "s", bus_property_get_oom_policy, offsetof(Service, oom_policy), SD_BUS_VTABLE_PROPERTY_CONST),

        BUS_EXEC_STATUS_VTABLE("ExecMain", offsetof(Service, main_exec_status), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        BUS_EXEC_COMMAND_LIST_VTABLE("ExecStartPre", offsetof(Service, exec_command[SERVICE_EXEC_START_PRE]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
        BUS_EXEC_EX_COMMAND_LIST_VTABLE("ExecStartPreEx", offsetof(Service, exec_command[SERVICE_EXEC_START_PRE]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
        BUS_EXEC_COMMAND_LIST_VTABLE("ExecStart", offsetof(Service, exec_command[SERVICE_EXEC_START]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
        BUS_EXEC_EX_COMMAND_LIST_VTABLE("ExecStartEx", offsetof(Service, exec_command[SERVICE_EXEC_START]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
        BUS_EXEC_COMMAND_LIST_VTABLE("ExecStartPost", offsetof(Service, exec_command[SERVICE_EXEC_START_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
        BUS_EXEC_EX_COMMAND_LIST_VTABLE("ExecStartPostEx", offsetof(Service, exec_command[SERVICE_EXEC_START_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
        BUS_EXEC_COMMAND_LIST_VTABLE("ExecReload", offsetof(Service, exec_command[SERVICE_EXEC_RELOAD]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
        BUS_EXEC_COMMAND_LIST_VTABLE("ExecStop", offsetof(Service, exec_command[SERVICE_EXEC_STOP]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
        BUS_EXEC_COMMAND_LIST_VTABLE("ExecStopPost", offsetof(Service, exec_command[SERVICE_EXEC_STOP_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),

        /* The following four are obsolete, and thus marked hidden here. They moved into the Unit interface */
        SD_BUS_PROPERTY("StartLimitInterval", "t", bus_property_get_usec, offsetof(Unit, start_limit.interval), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
        SD_BUS_PROPERTY("StartLimitBurst", "u", bus_property_get_unsigned, offsetof(Unit, start_limit.burst), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
        SD_BUS_PROPERTY("StartLimitAction", "s", property_get_emergency_action, offsetof(Unit, start_limit_action), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
        SD_BUS_PROPERTY("FailureAction", "s", property_get_emergency_action, offsetof(Unit, failure_action), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
        SD_BUS_PROPERTY("RebootArgument", "s", NULL, offsetof(Unit, reboot_arg), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
        SD_BUS_VTABLE_END
};

static int bus_set_transient_exit_status(
                Unit *u,
                const char *name,
                ExitStatusSet *status_set,
                sd_bus_message *message,
                UnitWriteFlags flags,
                sd_bus_error *error) {

        const int32_t *status, *signal;
        size_t sz_status, sz_signal, i;
        int r;

        r = sd_bus_message_enter_container(message, 'r', "aiai");
        if (r < 0)
                return r;

        r = sd_bus_message_read_array(message, 'i', (const void **) &status, &sz_status);
        if (r < 0)
                return r;

        r = sd_bus_message_read_array(message, 'i', (const void **) &signal, &sz_signal);
        if (r < 0)
                return r;

        r = sd_bus_message_exit_container(message);
        if (r < 0)
                return r;

        sz_status /= sizeof(int32_t);
        sz_signal /= sizeof(int32_t);

        if (sz_status == 0 && sz_signal == 0 && !UNIT_WRITE_FLAGS_NOOP(flags)) {
                exit_status_set_free(status_set);
                unit_write_settingf(u, flags, name, "%s=", name);
                return 1;
        }

        for (i = 0; i < sz_status; i++) {
                if (status[i] < 0 || status[i] > 255)
                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid status code in %s: %"PRIi32, name, status[i]);

                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        r = set_ensure_allocated(&status_set->status, NULL);
                        if (r < 0)
                                return r;

                        r = set_put(status_set->status, INT_TO_PTR((int) status[i]));
                        if (r < 0)
                                return r;

                        unit_write_settingf(u, flags, name, "%s=%"PRIi32, name, status[i]);
                }
        }

        for (i = 0; i < sz_signal; i++) {
                const char *str;

                str = signal_to_string((int) signal[i]);
                if (!str)
                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal in %s: %"PRIi32, name, signal[i]);

                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        r = set_ensure_allocated(&status_set->signal, NULL);
                        if (r < 0)
                                return r;

                        r = set_put(status_set->signal, INT_TO_PTR((int) signal[i]));
                        if (r < 0)
                                return r;

                        unit_write_settingf(u, flags, name, "%s=%s", name, str);
                }
        }

        return 1;
}

static int bus_set_transient_std_fd(
                Unit *u,
                const char *name,
                int *p,
                bool *b,
                sd_bus_message *message,
                UnitWriteFlags flags,
                sd_bus_error *error) {

        int fd, r;

        assert(p);
        assert(b);

        r = sd_bus_message_read(message, "h", &fd);
        if (r < 0)
                return r;

        if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                int copy;

                copy = fcntl(fd, F_DUPFD_CLOEXEC, 3);
                if (copy < 0)
                        return -errno;

                asynchronous_close(*p);
                *p = copy;
                *b = true;
        }

        return 1;
}
static BUS_DEFINE_SET_TRANSIENT_PARSE(notify_access, NotifyAccess, notify_access_from_string);
static BUS_DEFINE_SET_TRANSIENT_PARSE(service_type, ServiceType, service_type_from_string);
static BUS_DEFINE_SET_TRANSIENT_PARSE(service_restart, ServiceRestart, service_restart_from_string);
static BUS_DEFINE_SET_TRANSIENT_PARSE(oom_policy, OOMPolicy, oom_policy_from_string);
static BUS_DEFINE_SET_TRANSIENT_STRING_WITH_CHECK(bus_name, service_name_is_valid);

static int bus_service_set_transient_property(
                Service *s,
                const char *name,
                sd_bus_message *message,
                UnitWriteFlags flags,
                sd_bus_error *error) {

        Unit *u = UNIT(s);
        ServiceExecCommand ci;
        int r;

        assert(s);
        assert(name);
        assert(message);

        flags |= UNIT_PRIVATE;

        if (streq(name, "PermissionsStartOnly"))
                return bus_set_transient_bool(u, name, &s->permissions_start_only, message, flags, error);

        if (streq(name, "RootDirectoryStartOnly"))
                return bus_set_transient_bool(u, name, &s->root_directory_start_only, message, flags, error);

        if (streq(name, "RemainAfterExit"))
                return bus_set_transient_bool(u, name, &s->remain_after_exit, message, flags, error);

        if (streq(name, "GuessMainPID"))
                return bus_set_transient_bool(u, name, &s->guess_main_pid, message, flags, error);

        if (streq(name, "Type"))
                return bus_set_transient_service_type(u, name, &s->type, message, flags, error);

        if (streq(name, "OOMPolicy"))
                return bus_set_transient_oom_policy(u, name, &s->oom_policy, message, flags, error);

        if (streq(name, "RestartUSec"))
                return bus_set_transient_usec(u, name, &s->restart_usec, message, flags, error);

        if (streq(name, "TimeoutStartUSec")) {
                r = bus_set_transient_usec(u, name, &s->timeout_start_usec, message, flags, error);
                if (r >= 0 && !UNIT_WRITE_FLAGS_NOOP(flags))
                        s->start_timeout_defined = true;

                return r;
        }

        if (streq(name, "TimeoutStopUSec"))
                return bus_set_transient_usec(u, name, &s->timeout_stop_usec, message, flags, error);

        if (streq(name, "RuntimeMaxUSec"))
                return bus_set_transient_usec(u, name, &s->runtime_max_usec, message, flags, error);

        if (streq(name, "WatchdogUSec"))
                return bus_set_transient_usec(u, name, &s->watchdog_usec, message, flags, error);

        if (streq(name, "FileDescriptorStoreMax"))
                return bus_set_transient_unsigned(u, name, &s->n_fd_store_max, message, flags, error);

        if (streq(name, "NotifyAccess"))
                return bus_set_transient_notify_access(u, name, &s->notify_access, message, flags, error);

        if (streq(name, "PIDFile")) {
                _cleanup_free_ char *n = NULL;
                const char *v, *e;

                r = sd_bus_message_read(message, "s", &v);
                if (r < 0)
                        return r;

                if (!isempty(v)) {
                        n = path_make_absolute(v, u->manager->prefix[EXEC_DIRECTORY_RUNTIME]);
                        if (!n)
                                return -ENOMEM;

                        path_simplify(n, true);

                        if (!path_is_normalized(n))
                                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "PIDFile= path '%s' is not valid", n);

                        e = path_startswith(n, "/var/run/");
                        if (e) {
                                char *z;

                                z = strjoin("/run/", e);
                                if (!z)
                                        return log_oom();

                                if (!UNIT_WRITE_FLAGS_NOOP(flags))
                                        log_unit_notice(u, "Transient unit's PIDFile= property references path below legacy directory /var/run, updating %s → %s; please update client accordingly.", n, z);

                                free_and_replace(n, z);
                        }
                }

                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        free_and_replace(s->pid_file, n);
                        unit_write_settingf(u, flags, name, "%s=%s", name, strempty(s->pid_file));
                }

                return 1;
        }

        if (streq(name, "USBFunctionDescriptors"))
                return bus_set_transient_path(u, name, &s->usb_function_descriptors, message, flags, error);

        if (streq(name, "USBFunctionStrings"))
                return bus_set_transient_path(u, name, &s->usb_function_strings, message, flags, error);

        if (streq(name, "BusName"))
                return bus_set_transient_bus_name(u, name, &s->bus_name, message, flags, error);

        if (streq(name, "Restart"))
                return bus_set_transient_service_restart(u, name, &s->restart, message, flags, error);

        if (streq(name, "RestartPreventExitStatus"))
                return bus_set_transient_exit_status(u, name, &s->restart_prevent_status, message, flags, error);

        if (streq(name, "RestartForceExitStatus"))
                return bus_set_transient_exit_status(u, name, &s->restart_force_status, message, flags, error);

        if (streq(name, "SuccessExitStatus"))
                return bus_set_transient_exit_status(u, name, &s->success_status, message, flags, error);

        ci = service_exec_command_from_string(name);
        ci = (ci >= 0) ? ci : service_exec_ex_command_from_string(name);
        if (ci >= 0)
                return bus_set_transient_exec_command(u, name, &s->exec_command[ci], message, flags, error);

        if (streq(name, "StandardInputFileDescriptor"))
                return bus_set_transient_std_fd(u, name, &s->stdin_fd, &s->exec_context.stdio_as_fds, message, flags, error);

        if (streq(name, "StandardOutputFileDescriptor"))
                return bus_set_transient_std_fd(u, name, &s->stdout_fd, &s->exec_context.stdio_as_fds, message, flags, error);

        if (streq(name, "StandardErrorFileDescriptor"))
                return bus_set_transient_std_fd(u, name, &s->stderr_fd, &s->exec_context.stdio_as_fds, message, flags, error);

        return 0;
}

int bus_service_set_property(
                Unit *u,
                const char *name,
                sd_bus_message *message,
                UnitWriteFlags flags,
                sd_bus_error *error) {

        Service *s = SERVICE(u);
        int r;

        assert(s);
        assert(name);
        assert(message);

        r = bus_cgroup_set_property(u, &s->cgroup_context, name, message, flags, error);
        if (r != 0)
                return r;

        if (u->transient && u->load_state == UNIT_STUB) {
                /* This is a transient unit, let's load a little more */

                r = bus_service_set_transient_property(s, name, message, flags, error);
                if (r != 0)
                        return r;

                r = bus_exec_context_set_transient_property(u, &s->exec_context, name, message, flags, error);
                if (r != 0)
                        return r;

                r = bus_kill_context_set_transient_property(u, &s->kill_context, name, message, flags, error);
                if (r != 0)
                        return r;
        }

        return 0;
}

int bus_service_commit_properties(Unit *u) {
        assert(u);

        unit_invalidate_cgroup_members_masks(u);
        unit_realize_cgroup(u);

        return 0;
}
Commit	Line	Data
53e1b683	1	/* SPDX-License-Identifier: LGPL-2.1+ */
4139c1b2	2
ca78ad1d	3	#include <fcntl.h>
0d536673	4
b5efdb8a	5	#include "alloc-util.h"
a34ceba6	6	#include "async.h"
d2f05617	7	#include "bus-internal.h"
07630cea LP	8	#include "bus-util.h"
07630cea LP	9	#include "dbus-cgroup.h"
4139c1b2	10	#include "dbus-execute.h"
4819ff03	11	#include "dbus-kill.h"
afcfaa69	12	#include "dbus-manager.h"
3ffd4af2	13	#include "dbus-service.h"
d2f05617 YW	14	#include "dbus-util.h"
d2f05617 YW	15	#include "exit-status.h"
3ffd4af2	16	#include "fd-util.h"
0d39fa9c	17	#include "fileio.h"
d2f05617	18	#include "parse-util.h"
07630cea LP	19	#include "path-util.h"
07630cea LP	20	#include "service.h"
d2f05617	21	#include "signal-util.h"
07630cea LP	22	#include "string-util.h"
	23	#include "strv.h"
	24	#include "unit.h"
718db961 LP	25
	26	static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_type, service_type, ServiceType);
	27	static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_result, service_result, ServiceResult);
	28	static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_restart, service_restart, ServiceRestart);
	29	static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_notify_access, notify_access, NotifyAccess);
87a47f99	30	static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_emergency_action, emergency_action, EmergencyAction);
3bf0cb65	31	static BUS_DEFINE_PROPERTY_GET(property_get_timeout_abort_usec, "t", Service, service_timeout_abort_usec);
dc653bf4	32
dea700bf YW	33	static int property_get_exit_status_set(
	34	sd_bus *bus,
	35	const char *path,
	36	const char *interface,
	37	const char *property,
	38	sd_bus_message *reply,
	39	void *userdata,
	40	sd_bus_error *error) {
	41
	42	ExitStatusSet *status_set = userdata;
	43	Iterator i;
	44	void *id;
	45	int r;
	46
	47	assert(bus);
	48	assert(reply);
	49	assert(status_set);
	50
	51	r = sd_bus_message_open_container(reply, 'r', "aiai");
	52	if (r < 0)
	53	return r;
	54
	55	r = sd_bus_message_open_container(reply, 'a', "i");
	56	if (r < 0)
	57	return r;
	58
	59	SET_FOREACH(id, status_set->status, i) {
a672f4fe	60	int32_t val = PTR_TO_INT(id);
dea700bf YW	61
	62	if (val < 0 \|\| val > 255)
	63	continue;
	64
	65	r = sd_bus_message_append_basic(reply, 'i', &val);
	66	if (r < 0)
	67	return r;
	68	}
	69
	70	r = sd_bus_message_close_container(reply);
	71	if (r < 0)
	72	return r;
	73
	74	r = sd_bus_message_open_container(reply, 'a', "i");
	75	if (r < 0)
	76	return r;
	77
	78	SET_FOREACH(id, status_set->signal, i) {
a672f4fe	79	int32_t val = PTR_TO_INT(id);
dea700bf YW	80	const char *str;
dea700bf YW	81
a672f4fe	82	str = signal_to_string((int) val);
dea700bf YW	83	if (!str)
	84	continue;
	85
	86	r = sd_bus_message_append_basic(reply, 'i', &val);
	87	if (r < 0)
	88	return r;
	89	}
	90
	91	r = sd_bus_message_close_container(reply);
	92	if (r < 0)
	93	return r;
	94
	95	return sd_bus_message_close_container(reply);
	96	}
	97
718db961 LP	98	const sd_bus_vtable bus_service_vtable[] = {
718db961 LP	99	SD_BUS_VTABLE_START(0),
556089dc LP	100	SD_BUS_PROPERTY("Type", "s", property_get_type, offsetof(Service, type), SD_BUS_VTABLE_PROPERTY_CONST),
	101	SD_BUS_PROPERTY("Restart", "s", property_get_restart, offsetof(Service, restart), SD_BUS_VTABLE_PROPERTY_CONST),
	102	SD_BUS_PROPERTY("PIDFile", "s", NULL, offsetof(Service, pid_file), SD_BUS_VTABLE_PROPERTY_CONST),
	103	SD_BUS_PROPERTY("NotifyAccess", "s", property_get_notify_access, offsetof(Service, notify_access), SD_BUS_VTABLE_PROPERTY_CONST),
	104	SD_BUS_PROPERTY("RestartUSec", "t", bus_property_get_usec, offsetof(Service, restart_usec), SD_BUS_VTABLE_PROPERTY_CONST),
	105	SD_BUS_PROPERTY("TimeoutStartUSec", "t", bus_property_get_usec, offsetof(Service, timeout_start_usec), SD_BUS_VTABLE_PROPERTY_CONST),
	106	SD_BUS_PROPERTY("TimeoutStopUSec", "t", bus_property_get_usec, offsetof(Service, timeout_stop_usec), SD_BUS_VTABLE_PROPERTY_CONST),
dc653bf4	107	SD_BUS_PROPERTY("TimeoutAbortUSec", "t", property_get_timeout_abort_usec, 0, 0),
36c16a7c	108	SD_BUS_PROPERTY("RuntimeMaxUSec", "t", bus_property_get_usec, offsetof(Service, runtime_max_usec), SD_BUS_VTABLE_PROPERTY_CONST),
556089dc	109	SD_BUS_PROPERTY("WatchdogUSec", "t", bus_property_get_usec, offsetof(Service, watchdog_usec), SD_BUS_VTABLE_PROPERTY_CONST),
718db961	110	BUS_PROPERTY_DUAL_TIMESTAMP("WatchdogTimestamp", offsetof(Service, watchdog_timestamp), 0),
899feb72	111	SD_BUS_PROPERTY("PermissionsStartOnly", "b", bus_property_get_bool, offsetof(Service, permissions_start_only), SD_BUS_VTABLE_PROPERTY_CONST\|SD_BUS_VTABLE_HIDDEN), /* 😷 deprecated */
556089dc LP	112	SD_BUS_PROPERTY("RootDirectoryStartOnly", "b", bus_property_get_bool, offsetof(Service, root_directory_start_only), SD_BUS_VTABLE_PROPERTY_CONST),
	113	SD_BUS_PROPERTY("RemainAfterExit", "b", bus_property_get_bool, offsetof(Service, remain_after_exit), SD_BUS_VTABLE_PROPERTY_CONST),
	114	SD_BUS_PROPERTY("GuessMainPID", "b", bus_property_get_bool, offsetof(Service, guess_main_pid), SD_BUS_VTABLE_PROPERTY_CONST),
dea700bf YW	115	SD_BUS_PROPERTY("RestartPreventExitStatus", "(aiai)", property_get_exit_status_set, offsetof(Service, restart_prevent_status), SD_BUS_VTABLE_PROPERTY_CONST),
	116	SD_BUS_PROPERTY("RestartForceExitStatus", "(aiai)", property_get_exit_status_set, offsetof(Service, restart_force_status), SD_BUS_VTABLE_PROPERTY_CONST),
	117	SD_BUS_PROPERTY("SuccessExitStatus", "(aiai)", property_get_exit_status_set, offsetof(Service, success_status), SD_BUS_VTABLE_PROPERTY_CONST),
718db961 LP	118	SD_BUS_PROPERTY("MainPID", "u", bus_property_get_pid, offsetof(Service, main_pid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
718db961 LP	119	SD_BUS_PROPERTY("ControlPID", "u", bus_property_get_pid, offsetof(Service, control_pid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
556089dc	120	SD_BUS_PROPERTY("BusName", "s", NULL, offsetof(Service, bus_name), SD_BUS_VTABLE_PROPERTY_CONST),
d8e023aa LP	121	SD_BUS_PROPERTY("FileDescriptorStoreMax", "u", bus_property_get_unsigned, offsetof(Service, n_fd_store_max), SD_BUS_VTABLE_PROPERTY_CONST),
d8e023aa LP	122	SD_BUS_PROPERTY("NFileDescriptorStore", "u", bus_property_get_unsigned, offsetof(Service, n_fd_store), 0),
718db961	123	SD_BUS_PROPERTY("StatusText", "s", NULL, offsetof(Service, status_text), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
05156503	124	SD_BUS_PROPERTY("StatusErrno", "i", bus_property_get_int, offsetof(Service, status_errno), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
718db961	125	SD_BUS_PROPERTY("Result", "s", property_get_result, offsetof(Service, result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
ebf8d79a	126	SD_BUS_PROPERTY("ReloadResult", "s", property_get_result, offsetof(Service, reload_result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
b4525804 LP	127	SD_BUS_PROPERTY("USBFunctionDescriptors", "s", NULL, offsetof(Service, usb_function_descriptors), SD_BUS_VTABLE_PROPERTY_CONST),
b4525804 LP	128	SD_BUS_PROPERTY("USBFunctionStrings", "s", NULL, offsetof(Service, usb_function_strings), SD_BUS_VTABLE_PROPERTY_CONST),
05156503 YW	129	SD_BUS_PROPERTY("UID", "u", bus_property_get_uid, offsetof(Unit, ref_uid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
05156503 YW	130	SD_BUS_PROPERTY("GID", "u", bus_property_get_gid, offsetof(Unit, ref_gid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
7a0019d3	131	SD_BUS_PROPERTY("NRestarts", "u", bus_property_get_unsigned, offsetof(Service, n_restarts), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
afcfaa69	132	SD_BUS_PROPERTY("OOMPolicy", "s", bus_property_get_oom_policy, offsetof(Service, oom_policy), SD_BUS_VTABLE_PROPERTY_CONST),
00d9ef85	133
718db961	134	BUS_EXEC_STATUS_VTABLE("ExecMain", offsetof(Service, main_exec_status), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
556089dc	135	BUS_EXEC_COMMAND_LIST_VTABLE("ExecStartPre", offsetof(Service, exec_command[SERVICE_EXEC_START_PRE]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
b3d59367	136	BUS_EXEC_EX_COMMAND_LIST_VTABLE("ExecStartPreEx", offsetof(Service, exec_command[SERVICE_EXEC_START_PRE]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
556089dc	137	BUS_EXEC_COMMAND_LIST_VTABLE("ExecStart", offsetof(Service, exec_command[SERVICE_EXEC_START]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
b3d59367	138	BUS_EXEC_EX_COMMAND_LIST_VTABLE("ExecStartEx", offsetof(Service, exec_command[SERVICE_EXEC_START]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
556089dc	139	BUS_EXEC_COMMAND_LIST_VTABLE("ExecStartPost", offsetof(Service, exec_command[SERVICE_EXEC_START_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
b3d59367	140	BUS_EXEC_EX_COMMAND_LIST_VTABLE("ExecStartPostEx", offsetof(Service, exec_command[SERVICE_EXEC_START_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
556089dc LP	141	BUS_EXEC_COMMAND_LIST_VTABLE("ExecReload", offsetof(Service, exec_command[SERVICE_EXEC_RELOAD]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
	142	BUS_EXEC_COMMAND_LIST_VTABLE("ExecStop", offsetof(Service, exec_command[SERVICE_EXEC_STOP]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
	143	BUS_EXEC_COMMAND_LIST_VTABLE("ExecStopPost", offsetof(Service, exec_command[SERVICE_EXEC_STOP_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
51d73fd9 LP	144
	145	/* The following four are obsolete, and thus marked hidden here. They moved into the Unit interface */
	146	SD_BUS_PROPERTY("StartLimitInterval", "t", bus_property_get_usec, offsetof(Unit, start_limit.interval), SD_BUS_VTABLE_PROPERTY_CONST\|SD_BUS_VTABLE_HIDDEN),
	147	SD_BUS_PROPERTY("StartLimitBurst", "u", bus_property_get_unsigned, offsetof(Unit, start_limit.burst), SD_BUS_VTABLE_PROPERTY_CONST\|SD_BUS_VTABLE_HIDDEN),
87a47f99	148	SD_BUS_PROPERTY("StartLimitAction", "s", property_get_emergency_action, offsetof(Unit, start_limit_action), SD_BUS_VTABLE_PROPERTY_CONST\|SD_BUS_VTABLE_HIDDEN),
53c35a76	149	SD_BUS_PROPERTY("FailureAction", "s", property_get_emergency_action, offsetof(Unit, failure_action), SD_BUS_VTABLE_PROPERTY_CONST\|SD_BUS_VTABLE_HIDDEN),
51d73fd9	150	SD_BUS_PROPERTY("RebootArgument", "s", NULL, offsetof(Unit, reboot_arg), SD_BUS_VTABLE_PROPERTY_CONST\|SD_BUS_VTABLE_HIDDEN),
718db961	151	SD_BUS_VTABLE_END
d200735e MS	152	};
d200735e MS	153
d2f05617 YW	154	static int bus_set_transient_exit_status(
d2f05617 YW	155	Unit *u,
c2756a68	156	const char *name,
d2f05617	157	ExitStatusSet *status_set,
718db961	158	sd_bus_message *message,
2e59b241	159	UnitWriteFlags flags,
718db961	160	sd_bus_error *error) {
c2756a68	161
a672f4fe	162	const int32_t status, signal;
d2f05617	163	size_t sz_status, sz_signal, i;
c2756a68 LP	164	int r;
c2756a68 LP	165
d2f05617 YW	166	r = sd_bus_message_enter_container(message, 'r', "aiai");
	167	if (r < 0)
	168	return r;
c2756a68	169
d2f05617 YW	170	r = sd_bus_message_read_array(message, 'i', (const void **) &status, &sz_status);
	171	if (r < 0)
	172	return r;
2e59b241	173
d2f05617 YW	174	r = sd_bus_message_read_array(message, 'i', (const void **) &signal, &sz_signal);
	175	if (r < 0)
	176	return r;
6577c7ce	177
d2f05617 YW	178	r = sd_bus_message_exit_container(message);
	179	if (r < 0)
	180	return r;
6577c7ce	181
a672f4fe YW	182	sz_status /= sizeof(int32_t);
	183	sz_signal /= sizeof(int32_t);
	184
d2f05617 YW	185	if (sz_status == 0 && sz_signal == 0 && !UNIT_WRITE_FLAGS_NOOP(flags)) {
	186	exit_status_set_free(status_set);
	187	unit_write_settingf(u, flags, name, "%s=", name);
6577c7ce	188	return 1;
d2f05617	189	}
6577c7ce	190
d2f05617 YW	191	for (i = 0; i < sz_status; i++) {
d2f05617 YW	192	if (status[i] < 0 \|\| status[i] > 255)
a672f4fe	193	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid status code in %s: %"PRIi32, name, status[i]);
c7040b5d	194
d2f05617 YW	195	if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
	196	r = set_ensure_allocated(&status_set->status, NULL);
	197	if (r < 0)
	198	return r;
c7040b5d	199
a672f4fe	200	r = set_put(status_set->status, INT_TO_PTR((int) status[i]));
d2f05617 YW	201	if (r < 0)
d2f05617 YW	202	return r;
c7040b5d	203
a672f4fe	204	unit_write_settingf(u, flags, name, "%s=%"PRIi32, name, status[i]);
c7040b5d	205	}
d2f05617	206	}
c7040b5d	207
d2f05617 YW	208	for (i = 0; i < sz_signal; i++) {
d2f05617 YW	209	const char *str;
36c16a7c	210
a672f4fe	211	str = signal_to_string((int) signal[i]);
d2f05617	212	if (!str)
a672f4fe	213	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal in %s: %"PRIi32, name, signal[i]);
36c16a7c	214
2e59b241	215	if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
d2f05617 YW	216	r = set_ensure_allocated(&status_set->signal, NULL);
	217	if (r < 0)
	218	return r;
	219
a672f4fe	220	r = set_put(status_set->signal, INT_TO_PTR((int) signal[i]));
d2f05617 YW	221	if (r < 0)
	222	return r;
	223
	224	unit_write_settingf(u, flags, name, "%s=%s", name, str);
36c16a7c	225	}
d2f05617	226	}
36c16a7c	227
d2f05617 YW	228	return 1;
d2f05617 YW	229	}
c7040b5d	230
d2f05617 YW	231	static int bus_set_transient_std_fd(
	232	Unit *u,
	233	const char *name,
	234	int *p,
	235	bool *b,
	236	sd_bus_message *message,
	237	UnitWriteFlags flags,
	238	sd_bus_error *error) {
4ea0d7f4	239
d2f05617	240	int fd, r;
4ea0d7f4	241
d2f05617 YW	242	assert(p);
d2f05617 YW	243	assert(b);
4ea0d7f4	244
d2f05617 YW	245	r = sd_bus_message_read(message, "h", &fd);
	246	if (r < 0)
	247	return r;
4ea0d7f4	248
d2f05617 YW	249	if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
d2f05617 YW	250	int copy;
4ea0d7f4	251
d2f05617 YW	252	copy = fcntl(fd, F_DUPFD_CLOEXEC, 3);
	253	if (copy < 0)
	254	return -errno;
a34ceba6	255
d2f05617 YW	256	asynchronous_close(*p);
	257	*p = copy;
	258	*b = true;
	259	}
a34ceba6	260
d2f05617 YW	261	return 1;
	262	}
	263	static BUS_DEFINE_SET_TRANSIENT_PARSE(notify_access, NotifyAccess, notify_access_from_string);
	264	static BUS_DEFINE_SET_TRANSIENT_PARSE(service_type, ServiceType, service_type_from_string);
	265	static BUS_DEFINE_SET_TRANSIENT_PARSE(service_restart, ServiceRestart, service_restart_from_string);
afcfaa69	266	static BUS_DEFINE_SET_TRANSIENT_PARSE(oom_policy, OOMPolicy, oom_policy_from_string);
d2f05617	267	static BUS_DEFINE_SET_TRANSIENT_STRING_WITH_CHECK(bus_name, service_name_is_valid);
a34ceba6	268
d2f05617 YW	269	static int bus_service_set_transient_property(
	270	Service *s,
	271	const char *name,
	272	sd_bus_message *message,
	273	UnitWriteFlags flags,
	274	sd_bus_error *error) {
a34ceba6	275
d2f05617 YW	276	Unit *u = UNIT(s);
	277	ServiceExecCommand ci;
	278	int r;
9efb9df9	279
d2f05617 YW	280	assert(s);
	281	assert(name);
	282	assert(message);
9efb9df9	283
d2f05617	284	flags \|= UNIT_PRIVATE;
9efb9df9	285
d2f05617 YW	286	if (streq(name, "PermissionsStartOnly"))
d2f05617 YW	287	return bus_set_transient_bool(u, name, &s->permissions_start_only, message, flags, error);
9efb9df9	288
d2f05617 YW	289	if (streq(name, "RootDirectoryStartOnly"))
d2f05617 YW	290	return bus_set_transient_bool(u, name, &s->root_directory_start_only, message, flags, error);
9efb9df9	291
d2f05617 YW	292	if (streq(name, "RemainAfterExit"))
d2f05617 YW	293	return bus_set_transient_bool(u, name, &s->remain_after_exit, message, flags, error);
9efb9df9	294
d2f05617 YW	295	if (streq(name, "GuessMainPID"))
d2f05617 YW	296	return bus_set_transient_bool(u, name, &s->guess_main_pid, message, flags, error);
9efb9df9	297
d2f05617 YW	298	if (streq(name, "Type"))
d2f05617 YW	299	return bus_set_transient_service_type(u, name, &s->type, message, flags, error);
9efb9df9	300
afcfaa69 LP	301	if (streq(name, "OOMPolicy"))
	302	return bus_set_transient_oom_policy(u, name, &s->oom_policy, message, flags, error);
	303
d2f05617 YW	304	if (streq(name, "RestartUSec"))
	305	return bus_set_transient_usec(u, name, &s->restart_usec, message, flags, error);
	306
	307	if (streq(name, "TimeoutStartUSec")) {
	308	r = bus_set_transient_usec(u, name, &s->timeout_start_usec, message, flags, error);
	309	if (r >= 0 && !UNIT_WRITE_FLAGS_NOOP(flags))
	310	s->start_timeout_defined = true;
	311
	312	return r;
	313	}
	314
	315	if (streq(name, "TimeoutStopUSec"))
	316	return bus_set_transient_usec(u, name, &s->timeout_stop_usec, message, flags, error);
	317
	318	if (streq(name, "RuntimeMaxUSec"))
	319	return bus_set_transient_usec(u, name, &s->runtime_max_usec, message, flags, error);
	320
	321	if (streq(name, "WatchdogUSec"))
	322	return bus_set_transient_usec(u, name, &s->watchdog_usec, message, flags, error);
	323
	324	if (streq(name, "FileDescriptorStoreMax"))
	325	return bus_set_transient_unsigned(u, name, &s->n_fd_store_max, message, flags, error);
	326
	327	if (streq(name, "NotifyAccess"))
	328	return bus_set_transient_notify_access(u, name, &s->notify_access, message, flags, error);
	329
a9353a5c LP	330	if (streq(name, "PIDFile")) {
	331	_cleanup_free_ char *n = NULL;
	332	const char v, e;
	333
	334	r = sd_bus_message_read(message, "s", &v);
	335	if (r < 0)
	336	return r;
	337
64242fd3 YW	338	if (!isempty(v)) {
	339	n = path_make_absolute(v, u->manager->prefix[EXEC_DIRECTORY_RUNTIME]);
	340	if (!n)
	341	return -ENOMEM;
a9353a5c	342
64242fd3	343	path_simplify(n, true);
a9353a5c	344
64242fd3 YW	345	if (!path_is_normalized(n))
64242fd3 YW	346	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "PIDFile= path '%s' is not valid", n);
a9353a5c	347
64242fd3 YW	348	e = path_startswith(n, "/var/run/");
	349	if (e) {
	350	char *z;
a9353a5c	351
64242fd3 YW	352	z = strjoin("/run/", e);
	353	if (!z)
	354	return log_oom();
a9353a5c	355
64242fd3 YW	356	if (!UNIT_WRITE_FLAGS_NOOP(flags))
64242fd3 YW	357	log_unit_notice(u, "Transient unit's PIDFile= property references path below legacy directory /var/run, updating %s → %s; please update client accordingly.", n, z);
a9353a5c	358
64242fd3 YW	359	free_and_replace(n, z);
64242fd3 YW	360	}
c79d66fc YW	361	}
	362
	363	if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
a9353a5c	364	free_and_replace(s->pid_file, n);
64242fd3	365	unit_write_settingf(u, flags, name, "%s=%s", name, strempty(s->pid_file));
c79d66fc	366	}
a9353a5c LP	367
	368	return 1;
	369	}
d2f05617 YW	370
	371	if (streq(name, "USBFunctionDescriptors"))
	372	return bus_set_transient_path(u, name, &s->usb_function_descriptors, message, flags, error);
	373
	374	if (streq(name, "USBFunctionStrings"))
	375	return bus_set_transient_path(u, name, &s->usb_function_strings, message, flags, error);
	376
	377	if (streq(name, "BusName"))
	378	return bus_set_transient_bus_name(u, name, &s->bus_name, message, flags, error);
	379
	380	if (streq(name, "Restart"))
	381	return bus_set_transient_service_restart(u, name, &s->restart, message, flags, error);
	382
	383	if (streq(name, "RestartPreventExitStatus"))
	384	return bus_set_transient_exit_status(u, name, &s->restart_prevent_status, message, flags, error);
	385
	386	if (streq(name, "RestartForceExitStatus"))
	387	return bus_set_transient_exit_status(u, name, &s->restart_force_status, message, flags, error);
	388
	389	if (streq(name, "SuccessExitStatus"))
	390	return bus_set_transient_exit_status(u, name, &s->success_status, message, flags, error);
	391
be6bca47	392	ci = service_exec_command_from_string(name);
b3d59367	393	ci = (ci >= 0) ? ci : service_exec_ex_command_from_string(name);
be6bca47	394	if (ci >= 0)
d2f05617 YW	395	return bus_set_transient_exec_command(u, name, &s->exec_command[ci], message, flags, error);
	396
	397	if (streq(name, "StandardInputFileDescriptor"))
	398	return bus_set_transient_std_fd(u, name, &s->stdin_fd, &s->exec_context.stdio_as_fds, message, flags, error);
	399
	400	if (streq(name, "StandardOutputFileDescriptor"))
	401	return bus_set_transient_std_fd(u, name, &s->stdout_fd, &s->exec_context.stdio_as_fds, message, flags, error);
9efb9df9	402
d2f05617 YW	403	if (streq(name, "StandardErrorFileDescriptor"))
d2f05617 YW	404	return bus_set_transient_std_fd(u, name, &s->stderr_fd, &s->exec_context.stdio_as_fds, message, flags, error);
c2756a68 LP	405
	406	return 0;
	407	}
	408
74c964d3 LP	409	int bus_service_set_property(
	410	Unit *u,
	411	const char *name,
718db961	412	sd_bus_message *message,
2e59b241	413	UnitWriteFlags flags,
718db961	414	sd_bus_error *error) {
74c964d3 LP	415
	416	Service *s = SERVICE(u);
	417	int r;
	418
718db961	419	assert(s);
74c964d3	420	assert(name);
718db961	421	assert(message);
74c964d3	422
2e59b241	423	r = bus_cgroup_set_property(u, &s->cgroup_context, name, message, flags, error);
74c964d3 LP	424	if (r != 0)
	425	return r;
	426
c2756a68 LP	427	if (u->transient && u->load_state == UNIT_STUB) {
	428	/* This is a transient unit, let's load a little more */
	429
2e59b241	430	r = bus_service_set_transient_property(s, name, message, flags, error);
c2756a68 LP	431	if (r != 0)
c2756a68 LP	432	return r;
a6c0353b	433
2e59b241	434	r = bus_exec_context_set_transient_property(u, &s->exec_context, name, message, flags, error);
c7040b5d LP	435	if (r != 0)
	436	return r;
	437
2e59b241	438	r = bus_kill_context_set_transient_property(u, &s->kill_context, name, message, flags, error);
a6c0353b LP	439	if (r != 0)
a6c0353b LP	440	return r;
c2756a68 LP	441	}
c2756a68 LP	442
74c964d3 LP	443	return 0;
	444	}
	445
	446	int bus_service_commit_properties(Unit *u) {
	447	assert(u);
	448
5af88058	449	unit_invalidate_cgroup_members_masks(u);
74c964d3	450	unit_realize_cgroup(u);
bc432dc7	451
74c964d3 LP	452	return 0;
74c964d3 LP	453	}