[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 int property_get_timeout_abort_usec(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {

        Service *s = userdata;
        usec_t t;

        assert(bus);
        assert(reply);
        assert(s);

        t = service_timeout_abort_usec(s);

        return sd_bus_message_append(reply, "t", t);
}

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