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

/* SPDX-License-Identifier: LGPL-2.1+ */
/***
  Copyright 2010 Lennart Poettering
***/

#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_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_EMITS_CHANGE),
        SD_BUS_PROPERTY("USBFunctionStrings", "s", NULL, offsetof(Service, usb_function_strings), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        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"))
                return bus_set_transient_path(u, name, &s->pid_file, message, flags, error);

        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_update_cgroup_members_masks(u);
        unit_realize_cgroup(u);

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