[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_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);
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 LP	135	BUS_EXEC_COMMAND_LIST_VTABLE("ExecStartPre", offsetof(Service, exec_command[SERVICE_EXEC_START_PRE]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
	136	BUS_EXEC_COMMAND_LIST_VTABLE("ExecStart", offsetof(Service, exec_command[SERVICE_EXEC_START]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
	137	BUS_EXEC_COMMAND_LIST_VTABLE("ExecStartPost", offsetof(Service, exec_command[SERVICE_EXEC_START_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
	138	BUS_EXEC_COMMAND_LIST_VTABLE("ExecReload", offsetof(Service, exec_command[SERVICE_EXEC_RELOAD]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
	139	BUS_EXEC_COMMAND_LIST_VTABLE("ExecStop", offsetof(Service, exec_command[SERVICE_EXEC_STOP]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
	140	BUS_EXEC_COMMAND_LIST_VTABLE("ExecStopPost", offsetof(Service, exec_command[SERVICE_EXEC_STOP_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
51d73fd9 LP	141
	142	/* The following four are obsolete, and thus marked hidden here. They moved into the Unit interface */
	143	SD_BUS_PROPERTY("StartLimitInterval", "t", bus_property_get_usec, offsetof(Unit, start_limit.interval), SD_BUS_VTABLE_PROPERTY_CONST\|SD_BUS_VTABLE_HIDDEN),
	144	SD_BUS_PROPERTY("StartLimitBurst", "u", bus_property_get_unsigned, offsetof(Unit, start_limit.burst), SD_BUS_VTABLE_PROPERTY_CONST\|SD_BUS_VTABLE_HIDDEN),
87a47f99	145	SD_BUS_PROPERTY("StartLimitAction", "s", property_get_emergency_action, offsetof(Unit, start_limit_action), SD_BUS_VTABLE_PROPERTY_CONST\|SD_BUS_VTABLE_HIDDEN),
53c35a76	146	SD_BUS_PROPERTY("FailureAction", "s", property_get_emergency_action, offsetof(Unit, failure_action), SD_BUS_VTABLE_PROPERTY_CONST\|SD_BUS_VTABLE_HIDDEN),
51d73fd9	147	SD_BUS_PROPERTY("RebootArgument", "s", NULL, offsetof(Unit, reboot_arg), SD_BUS_VTABLE_PROPERTY_CONST\|SD_BUS_VTABLE_HIDDEN),
718db961	148	SD_BUS_VTABLE_END
d200735e MS	149	};
d200735e MS	150
d2f05617 YW	151	static int bus_set_transient_exit_status(
d2f05617 YW	152	Unit *u,
c2756a68	153	const char *name,
d2f05617	154	ExitStatusSet *status_set,
718db961	155	sd_bus_message *message,
2e59b241	156	UnitWriteFlags flags,
718db961	157	sd_bus_error *error) {
c2756a68	158
a672f4fe	159	const int32_t status, signal;
d2f05617	160	size_t sz_status, sz_signal, i;
c2756a68 LP	161	int r;
c2756a68 LP	162
d2f05617 YW	163	r = sd_bus_message_enter_container(message, 'r', "aiai");
	164	if (r < 0)
	165	return r;
c2756a68	166
d2f05617 YW	167	r = sd_bus_message_read_array(message, 'i', (const void **) &status, &sz_status);
	168	if (r < 0)
	169	return r;
2e59b241	170
d2f05617 YW	171	r = sd_bus_message_read_array(message, 'i', (const void **) &signal, &sz_signal);
	172	if (r < 0)
	173	return r;
6577c7ce	174
d2f05617 YW	175	r = sd_bus_message_exit_container(message);
	176	if (r < 0)
	177	return r;
6577c7ce	178
a672f4fe YW	179	sz_status /= sizeof(int32_t);
	180	sz_signal /= sizeof(int32_t);
	181
d2f05617 YW	182	if (sz_status == 0 && sz_signal == 0 && !UNIT_WRITE_FLAGS_NOOP(flags)) {
	183	exit_status_set_free(status_set);
	184	unit_write_settingf(u, flags, name, "%s=", name);
6577c7ce	185	return 1;
d2f05617	186	}
6577c7ce	187
d2f05617 YW	188	for (i = 0; i < sz_status; i++) {
d2f05617 YW	189	if (status[i] < 0 \|\| status[i] > 255)
a672f4fe	190	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid status code in %s: %"PRIi32, name, status[i]);
c7040b5d	191
d2f05617 YW	192	if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
	193	r = set_ensure_allocated(&status_set->status, NULL);
	194	if (r < 0)
	195	return r;
c7040b5d	196
a672f4fe	197	r = set_put(status_set->status, INT_TO_PTR((int) status[i]));
d2f05617 YW	198	if (r < 0)
d2f05617 YW	199	return r;
c7040b5d	200
a672f4fe	201	unit_write_settingf(u, flags, name, "%s=%"PRIi32, name, status[i]);
c7040b5d	202	}
d2f05617	203	}
c7040b5d	204
d2f05617 YW	205	for (i = 0; i < sz_signal; i++) {
d2f05617 YW	206	const char *str;
36c16a7c	207
a672f4fe	208	str = signal_to_string((int) signal[i]);
d2f05617	209	if (!str)
a672f4fe	210	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal in %s: %"PRIi32, name, signal[i]);
36c16a7c	211
2e59b241	212	if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
d2f05617 YW	213	r = set_ensure_allocated(&status_set->signal, NULL);
	214	if (r < 0)
	215	return r;
	216
a672f4fe	217	r = set_put(status_set->signal, INT_TO_PTR((int) signal[i]));
d2f05617 YW	218	if (r < 0)
	219	return r;
	220
	221	unit_write_settingf(u, flags, name, "%s=%s", name, str);
36c16a7c	222	}
d2f05617	223	}
36c16a7c	224
d2f05617 YW	225	return 1;
d2f05617 YW	226	}
c7040b5d	227
d2f05617 YW	228	static int bus_set_transient_std_fd(
	229	Unit *u,
	230	const char *name,
	231	int *p,
	232	bool *b,
	233	sd_bus_message *message,
	234	UnitWriteFlags flags,
	235	sd_bus_error *error) {
4ea0d7f4	236
d2f05617	237	int fd, r;
4ea0d7f4	238
d2f05617 YW	239	assert(p);
d2f05617 YW	240	assert(b);
4ea0d7f4	241
d2f05617 YW	242	r = sd_bus_message_read(message, "h", &fd);
	243	if (r < 0)
	244	return r;
4ea0d7f4	245
d2f05617 YW	246	if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
d2f05617 YW	247	int copy;
4ea0d7f4	248
d2f05617 YW	249	copy = fcntl(fd, F_DUPFD_CLOEXEC, 3);
	250	if (copy < 0)
	251	return -errno;
a34ceba6	252
d2f05617 YW	253	asynchronous_close(*p);
	254	*p = copy;
	255	*b = true;
	256	}
a34ceba6	257
d2f05617 YW	258	return 1;
	259	}
	260	static BUS_DEFINE_SET_TRANSIENT_PARSE(notify_access, NotifyAccess, notify_access_from_string);
	261	static BUS_DEFINE_SET_TRANSIENT_PARSE(service_type, ServiceType, service_type_from_string);
	262	static BUS_DEFINE_SET_TRANSIENT_PARSE(service_restart, ServiceRestart, service_restart_from_string);
afcfaa69	263	static BUS_DEFINE_SET_TRANSIENT_PARSE(oom_policy, OOMPolicy, oom_policy_from_string);
d2f05617	264	static BUS_DEFINE_SET_TRANSIENT_STRING_WITH_CHECK(bus_name, service_name_is_valid);
a34ceba6	265
d2f05617 YW	266	static int bus_service_set_transient_property(
	267	Service *s,
	268	const char *name,
	269	sd_bus_message *message,
	270	UnitWriteFlags flags,
	271	sd_bus_error *error) {
a34ceba6	272
d2f05617 YW	273	Unit *u = UNIT(s);
	274	ServiceExecCommand ci;
	275	int r;
9efb9df9	276
d2f05617 YW	277	assert(s);
	278	assert(name);
	279	assert(message);
9efb9df9	280
d2f05617	281	flags \|= UNIT_PRIVATE;
9efb9df9	282
d2f05617 YW	283	if (streq(name, "PermissionsStartOnly"))
d2f05617 YW	284	return bus_set_transient_bool(u, name, &s->permissions_start_only, message, flags, error);
9efb9df9	285
d2f05617 YW	286	if (streq(name, "RootDirectoryStartOnly"))
d2f05617 YW	287	return bus_set_transient_bool(u, name, &s->root_directory_start_only, message, flags, error);
9efb9df9	288
d2f05617 YW	289	if (streq(name, "RemainAfterExit"))
d2f05617 YW	290	return bus_set_transient_bool(u, name, &s->remain_after_exit, message, flags, error);
9efb9df9	291
d2f05617 YW	292	if (streq(name, "GuessMainPID"))
d2f05617 YW	293	return bus_set_transient_bool(u, name, &s->guess_main_pid, message, flags, error);
9efb9df9	294
d2f05617 YW	295	if (streq(name, "Type"))
d2f05617 YW	296	return bus_set_transient_service_type(u, name, &s->type, message, flags, error);
9efb9df9	297
afcfaa69 LP	298	if (streq(name, "OOMPolicy"))
	299	return bus_set_transient_oom_policy(u, name, &s->oom_policy, message, flags, error);
	300
d2f05617 YW	301	if (streq(name, "RestartUSec"))
	302	return bus_set_transient_usec(u, name, &s->restart_usec, message, flags, error);
	303
	304	if (streq(name, "TimeoutStartUSec")) {
	305	r = bus_set_transient_usec(u, name, &s->timeout_start_usec, message, flags, error);
	306	if (r >= 0 && !UNIT_WRITE_FLAGS_NOOP(flags))
	307	s->start_timeout_defined = true;
	308
	309	return r;
	310	}
	311
	312	if (streq(name, "TimeoutStopUSec"))
	313	return bus_set_transient_usec(u, name, &s->timeout_stop_usec, message, flags, error);
	314
	315	if (streq(name, "RuntimeMaxUSec"))
	316	return bus_set_transient_usec(u, name, &s->runtime_max_usec, message, flags, error);
	317
	318	if (streq(name, "WatchdogUSec"))
	319	return bus_set_transient_usec(u, name, &s->watchdog_usec, message, flags, error);
	320
	321	if (streq(name, "FileDescriptorStoreMax"))
	322	return bus_set_transient_unsigned(u, name, &s->n_fd_store_max, message, flags, error);
	323
	324	if (streq(name, "NotifyAccess"))
	325	return bus_set_transient_notify_access(u, name, &s->notify_access, message, flags, error);
	326
a9353a5c LP	327	if (streq(name, "PIDFile")) {
	328	_cleanup_free_ char *n = NULL;
	329	const char v, e;
	330
	331	r = sd_bus_message_read(message, "s", &v);
	332	if (r < 0)
	333	return r;
	334
64242fd3 YW	335	if (!isempty(v)) {
	336	n = path_make_absolute(v, u->manager->prefix[EXEC_DIRECTORY_RUNTIME]);
	337	if (!n)
	338	return -ENOMEM;
a9353a5c	339
64242fd3	340	path_simplify(n, true);
a9353a5c	341
64242fd3 YW	342	if (!path_is_normalized(n))
64242fd3 YW	343	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "PIDFile= path '%s' is not valid", n);
a9353a5c	344
64242fd3 YW	345	e = path_startswith(n, "/var/run/");
	346	if (e) {
	347	char *z;
a9353a5c	348
64242fd3 YW	349	z = strjoin("/run/", e);
	350	if (!z)
	351	return log_oom();
a9353a5c	352
64242fd3 YW	353	if (!UNIT_WRITE_FLAGS_NOOP(flags))
64242fd3 YW	354	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	355
64242fd3 YW	356	free_and_replace(n, z);
64242fd3 YW	357	}
c79d66fc YW	358	}
	359
	360	if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
a9353a5c	361	free_and_replace(s->pid_file, n);
64242fd3	362	unit_write_settingf(u, flags, name, "%s=%s", name, strempty(s->pid_file));
c79d66fc	363	}
a9353a5c LP	364
	365	return 1;
	366	}
d2f05617 YW	367
	368	if (streq(name, "USBFunctionDescriptors"))
	369	return bus_set_transient_path(u, name, &s->usb_function_descriptors, message, flags, error);
	370
	371	if (streq(name, "USBFunctionStrings"))
	372	return bus_set_transient_path(u, name, &s->usb_function_strings, message, flags, error);
	373
	374	if (streq(name, "BusName"))
	375	return bus_set_transient_bus_name(u, name, &s->bus_name, message, flags, error);
	376
	377	if (streq(name, "Restart"))
	378	return bus_set_transient_service_restart(u, name, &s->restart, message, flags, error);
	379
	380	if (streq(name, "RestartPreventExitStatus"))
	381	return bus_set_transient_exit_status(u, name, &s->restart_prevent_status, message, flags, error);
	382
	383	if (streq(name, "RestartForceExitStatus"))
	384	return bus_set_transient_exit_status(u, name, &s->restart_force_status, message, flags, error);
	385
	386	if (streq(name, "SuccessExitStatus"))
	387	return bus_set_transient_exit_status(u, name, &s->success_status, message, flags, error);
	388
be6bca47 LP	389	ci = service_exec_command_from_string(name);
be6bca47 LP	390	if (ci >= 0)
d2f05617 YW	391	return bus_set_transient_exec_command(u, name, &s->exec_command[ci], message, flags, error);
	392
	393	if (streq(name, "StandardInputFileDescriptor"))
	394	return bus_set_transient_std_fd(u, name, &s->stdin_fd, &s->exec_context.stdio_as_fds, message, flags, error);
	395
	396	if (streq(name, "StandardOutputFileDescriptor"))
	397	return bus_set_transient_std_fd(u, name, &s->stdout_fd, &s->exec_context.stdio_as_fds, message, flags, error);
9efb9df9	398
d2f05617 YW	399	if (streq(name, "StandardErrorFileDescriptor"))
d2f05617 YW	400	return bus_set_transient_std_fd(u, name, &s->stderr_fd, &s->exec_context.stdio_as_fds, message, flags, error);
c2756a68 LP	401
	402	return 0;
	403	}
	404
74c964d3 LP	405	int bus_service_set_property(
	406	Unit *u,
	407	const char *name,
718db961	408	sd_bus_message *message,
2e59b241	409	UnitWriteFlags flags,
718db961	410	sd_bus_error *error) {
74c964d3 LP	411
	412	Service *s = SERVICE(u);
	413	int r;
	414
718db961	415	assert(s);
74c964d3	416	assert(name);
718db961	417	assert(message);
74c964d3	418
2e59b241	419	r = bus_cgroup_set_property(u, &s->cgroup_context, name, message, flags, error);
74c964d3 LP	420	if (r != 0)
	421	return r;
	422
c2756a68 LP	423	if (u->transient && u->load_state == UNIT_STUB) {
	424	/* This is a transient unit, let's load a little more */
	425
2e59b241	426	r = bus_service_set_transient_property(s, name, message, flags, error);
c2756a68 LP	427	if (r != 0)
c2756a68 LP	428	return r;
a6c0353b	429
2e59b241	430	r = bus_exec_context_set_transient_property(u, &s->exec_context, name, message, flags, error);
c7040b5d LP	431	if (r != 0)
	432	return r;
	433
2e59b241	434	r = bus_kill_context_set_transient_property(u, &s->kill_context, name, message, flags, error);
a6c0353b LP	435	if (r != 0)
a6c0353b LP	436	return r;
c2756a68 LP	437	}
c2756a68 LP	438
74c964d3 LP	439	return 0;
	440	}
	441
	442	int bus_service_commit_properties(Unit *u) {
	443	assert(u);
	444
5af88058	445	unit_invalidate_cgroup_members_masks(u);
74c964d3	446	unit_realize_cgroup(u);
bc432dc7	447
74c964d3 LP	448	return 0;
74c964d3 LP	449	}