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

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

#include <stdio_ext.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-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_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) {
                int 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) {
                int val = PTR_TO_INT(id);
                const char *str;

                str = signal_to_string(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("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("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),

        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 int *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;

        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: %i", 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(status[i]));
                        if (r < 0)
                                return r;

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

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

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