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

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2010 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include "alloc-util.h"
#include "async.h"
#include "bus-util.h"
#include "dbus-cgroup.h"
#include "dbus-execute.h"
#include "dbus-kill.h"
#include "dbus-service.h"
#include "fd-util.h"
#include "fileio.h"
#include "path-util.h"
#include "service.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_failure_action, failure_action, FailureAction);

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("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("StartLimitInterval", "t", bus_property_get_usec, offsetof(Service, start_limit.interval), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("StartLimitBurst", "u", bus_property_get_unsigned, offsetof(Service, start_limit.burst), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("StartLimitAction", "s", property_get_failure_action, offsetof(Service, start_limit_action), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("RebootArgument", "s", NULL, offsetof(Service, reboot_arg), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("FailureAction", "s", property_get_failure_action, offsetof(Service, failure_action), SD_BUS_VTABLE_PROPERTY_CONST),
        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("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", NULL, offsetof(Service, n_fd_store_max), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("StatusText", "s", NULL, offsetof(Service, status_text), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("StatusErrno", "i", NULL, 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),
        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),
        SD_BUS_VTABLE_END
};

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

        int r;

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

        if (streq(name, "RemainAfterExit")) {
                int b;

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

                if (mode != UNIT_CHECK) {
                        s->remain_after_exit = b;
                        unit_write_drop_in_private_format(UNIT(s), mode, name, "RemainAfterExit=%s\n", yes_no(b));
                }

                return 1;

        } else if (streq(name, "Type")) {
                const char *t;
                ServiceType k;

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

                k = service_type_from_string(t);
                if (k < 0)
                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid service type %s", t);

                if (mode != UNIT_CHECK) {
                        s->type = k;
                        unit_write_drop_in_private_format(UNIT(s), mode, name, "Type=%s\n", service_type_to_string(s->type));
                }

                return 1;

        } else if (STR_IN_SET(name,
                              "StandardInputFileDescriptor",
                              "StandardOutputFileDescriptor",
                              "StandardErrorFileDescriptor")) {
                int fd;

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

                if (mode != UNIT_CHECK) {
                        int copy;

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

                        if (streq(name, "StandardInputFileDescriptor")) {
                                asynchronous_close(s->stdin_fd);
                                s->stdin_fd = copy;
                        } else if (streq(name, "StandardOutputFileDescriptor")) {
                                asynchronous_close(s->stdout_fd);
                                s->stdout_fd = copy;
                        } else {
                                asynchronous_close(s->stderr_fd);
                                s->stderr_fd = copy;
                        }
                }

                return 1;

        } else if (streq(name, "ExecStart")) {
                unsigned n = 0;

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

                while ((r = sd_bus_message_enter_container(message, 'r', "sasb")) > 0) {
                        _cleanup_strv_free_ char **argv = NULL;
                        const char *path;
                        int b;

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

                        if (!path_is_absolute(path))
                                return sd_bus_error_set_errnof(error, EINVAL, "Path %s is not absolute.", path);

                        r = sd_bus_message_read_strv(message, &argv);
                        if (r < 0)
                                return r;

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

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

                        if (mode != UNIT_CHECK) {
                                ExecCommand *c;

                                c = new0(ExecCommand, 1);
                                if (!c)
                                        return -ENOMEM;

                                c->path = strdup(path);
                                if (!c->path) {
                                        free(c);
                                        return -ENOMEM;
                                }

                                c->argv = argv;
                                argv = NULL;

                                c->ignore = b;

                                path_kill_slashes(c->path);
                                exec_command_append_list(&s->exec_command[SERVICE_EXEC_START], c);
                        }

                        n++;
                }

                if (r < 0)
                        return r;

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

                if (mode != UNIT_CHECK) {
                        _cleanup_free_ char *buf = NULL;
                        _cleanup_fclose_ FILE *f = NULL;
                        ExecCommand *c;
                        size_t size = 0;

                        if (n == 0)
                                s->exec_command[SERVICE_EXEC_START] = exec_command_free_list(s->exec_command[SERVICE_EXEC_START]);

                        f = open_memstream(&buf, &size);
                        if (!f)
                                return -ENOMEM;

                        fputs("ExecStart=\n", f);

                        LIST_FOREACH(command, c, s->exec_command[SERVICE_EXEC_START]) {
                                _cleanup_free_ char *a;

                                a = strv_join_quoted(c->argv);
                                if (!a)
                                        return -ENOMEM;

                                fprintf(f, "ExecStart=%s@%s %s\n",
                                        c->ignore ? "-" : "",
                                        c->path,
                                        a);
                        }

                        r = fflush_and_check(f);
                        if (r < 0)
                                return r;
                        unit_write_drop_in_private(UNIT(s), mode, name, buf);
                }

                return 1;
        }

        return 0;
}

int bus_service_set_property(
                Unit *u,
                const char *name,
                sd_bus_message *message,
                UnitSetPropertiesMode mode,
                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, mode, 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, mode, error);
                if (r != 0)
                        return r;

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

                r = bus_kill_context_set_transient_property(u, &s->kill_context, name, message, mode, 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
d6c9574f	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
4139c1b2 LP	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2010 Lennart Poettering
	7
	8	systemd is free software; you can redistribute it and/or modify it
5430f7f2 LP	9	under the terms of the GNU Lesser General Public License as published by
5430f7f2 LP	10	the Free Software Foundation; either version 2.1 of the License, or
4139c1b2 LP	11	(at your option) any later version.
	12
	13	systemd is distributed in the hope that it will be useful, but
	14	WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
5430f7f2	16	Lesser General Public License for more details.
4139c1b2	17
5430f7f2	18	You should have received a copy of the GNU Lesser General Public License
4139c1b2 LP	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
b5efdb8a	22	#include "alloc-util.h"
a34ceba6	23	#include "async.h"
07630cea LP	24	#include "bus-util.h"
07630cea LP	25	#include "dbus-cgroup.h"
4139c1b2	26	#include "dbus-execute.h"
4819ff03	27	#include "dbus-kill.h"
3ffd4af2 LP	28	#include "dbus-service.h"
3ffd4af2 LP	29	#include "fd-util.h"
0d39fa9c	30	#include "fileio.h"
07630cea LP	31	#include "path-util.h"
	32	#include "service.h"
	33	#include "string-util.h"
	34	#include "strv.h"
	35	#include "unit.h"
718db961 LP	36
	37	static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_type, service_type, ServiceType);
	38	static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_result, service_result, ServiceResult);
	39	static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_restart, service_restart, ServiceRestart);
	40	static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_notify_access, notify_access, NotifyAccess);
bf500566	41	static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_failure_action, failure_action, FailureAction);
718db961 LP	42
	43	const sd_bus_vtable bus_service_vtable[] = {
	44	SD_BUS_VTABLE_START(0),
556089dc LP	45	SD_BUS_PROPERTY("Type", "s", property_get_type, offsetof(Service, type), SD_BUS_VTABLE_PROPERTY_CONST),
	46	SD_BUS_PROPERTY("Restart", "s", property_get_restart, offsetof(Service, restart), SD_BUS_VTABLE_PROPERTY_CONST),
	47	SD_BUS_PROPERTY("PIDFile", "s", NULL, offsetof(Service, pid_file), SD_BUS_VTABLE_PROPERTY_CONST),
	48	SD_BUS_PROPERTY("NotifyAccess", "s", property_get_notify_access, offsetof(Service, notify_access), SD_BUS_VTABLE_PROPERTY_CONST),
	49	SD_BUS_PROPERTY("RestartUSec", "t", bus_property_get_usec, offsetof(Service, restart_usec), SD_BUS_VTABLE_PROPERTY_CONST),
	50	SD_BUS_PROPERTY("TimeoutStartUSec", "t", bus_property_get_usec, offsetof(Service, timeout_start_usec), SD_BUS_VTABLE_PROPERTY_CONST),
	51	SD_BUS_PROPERTY("TimeoutStopUSec", "t", bus_property_get_usec, offsetof(Service, timeout_stop_usec), SD_BUS_VTABLE_PROPERTY_CONST),
	52	SD_BUS_PROPERTY("WatchdogUSec", "t", bus_property_get_usec, offsetof(Service, watchdog_usec), SD_BUS_VTABLE_PROPERTY_CONST),
718db961	53	BUS_PROPERTY_DUAL_TIMESTAMP("WatchdogTimestamp", offsetof(Service, watchdog_timestamp), 0),
556089dc LP	54	SD_BUS_PROPERTY("StartLimitInterval", "t", bus_property_get_usec, offsetof(Service, start_limit.interval), SD_BUS_VTABLE_PROPERTY_CONST),
556089dc LP	55	SD_BUS_PROPERTY("StartLimitBurst", "u", bus_property_get_unsigned, offsetof(Service, start_limit.burst), SD_BUS_VTABLE_PROPERTY_CONST),
bf500566	56	SD_BUS_PROPERTY("StartLimitAction", "s", property_get_failure_action, offsetof(Service, start_limit_action), SD_BUS_VTABLE_PROPERTY_CONST),
efe6e7d3	57	SD_BUS_PROPERTY("RebootArgument", "s", NULL, offsetof(Service, reboot_arg), SD_BUS_VTABLE_PROPERTY_CONST),
bf500566	58	SD_BUS_PROPERTY("FailureAction", "s", property_get_failure_action, offsetof(Service, failure_action), SD_BUS_VTABLE_PROPERTY_CONST),
556089dc LP	59	SD_BUS_PROPERTY("PermissionsStartOnly", "b", bus_property_get_bool, offsetof(Service, permissions_start_only), SD_BUS_VTABLE_PROPERTY_CONST),
	60	SD_BUS_PROPERTY("RootDirectoryStartOnly", "b", bus_property_get_bool, offsetof(Service, root_directory_start_only), SD_BUS_VTABLE_PROPERTY_CONST),
	61	SD_BUS_PROPERTY("RemainAfterExit", "b", bus_property_get_bool, offsetof(Service, remain_after_exit), SD_BUS_VTABLE_PROPERTY_CONST),
	62	SD_BUS_PROPERTY("GuessMainPID", "b", bus_property_get_bool, offsetof(Service, guess_main_pid), SD_BUS_VTABLE_PROPERTY_CONST),
718db961 LP	63	SD_BUS_PROPERTY("MainPID", "u", bus_property_get_pid, offsetof(Service, main_pid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
718db961 LP	64	SD_BUS_PROPERTY("ControlPID", "u", bus_property_get_pid, offsetof(Service, control_pid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
556089dc	65	SD_BUS_PROPERTY("BusName", "s", NULL, offsetof(Service, bus_name), SD_BUS_VTABLE_PROPERTY_CONST),
a354329f	66	SD_BUS_PROPERTY("FileDescriptorStoreMax", "u", NULL, offsetof(Service, n_fd_store_max), SD_BUS_VTABLE_PROPERTY_CONST),
718db961	67	SD_BUS_PROPERTY("StatusText", "s", NULL, offsetof(Service, status_text), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
4774e357	68	SD_BUS_PROPERTY("StatusErrno", "i", NULL, offsetof(Service, status_errno), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
718db961	69	SD_BUS_PROPERTY("Result", "s", property_get_result, offsetof(Service, result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
6b7e5923 PS	70	SD_BUS_PROPERTY("USBFunctionDescriptors", "s", NULL, offsetof(Service, usb_function_descriptors), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
6b7e5923 PS	71	SD_BUS_PROPERTY("USBFunctionStrings", "s", NULL, offsetof(Service, usb_function_strings), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
718db961	72	BUS_EXEC_STATUS_VTABLE("ExecMain", offsetof(Service, main_exec_status), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
556089dc LP	73	BUS_EXEC_COMMAND_LIST_VTABLE("ExecStartPre", offsetof(Service, exec_command[SERVICE_EXEC_START_PRE]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
	74	BUS_EXEC_COMMAND_LIST_VTABLE("ExecStart", offsetof(Service, exec_command[SERVICE_EXEC_START]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
	75	BUS_EXEC_COMMAND_LIST_VTABLE("ExecStartPost", offsetof(Service, exec_command[SERVICE_EXEC_START_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
	76	BUS_EXEC_COMMAND_LIST_VTABLE("ExecReload", offsetof(Service, exec_command[SERVICE_EXEC_RELOAD]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
	77	BUS_EXEC_COMMAND_LIST_VTABLE("ExecStop", offsetof(Service, exec_command[SERVICE_EXEC_STOP]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
	78	BUS_EXEC_COMMAND_LIST_VTABLE("ExecStopPost", offsetof(Service, exec_command[SERVICE_EXEC_STOP_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
718db961	79	SD_BUS_VTABLE_END
d200735e MS	80	};
d200735e MS	81
9f2e86af	82	static int bus_service_set_transient_property(
c2756a68 LP	83	Service *s,
c2756a68 LP	84	const char *name,
718db961	85	sd_bus_message *message,
c2756a68	86	UnitSetPropertiesMode mode,
718db961	87	sd_bus_error *error) {
c2756a68 LP	88
	89	int r;
	90
c2756a68	91	assert(s);
718db961 LP	92	assert(name);
718db961 LP	93	assert(message);
c2756a68	94
6577c7ce	95	if (streq(name, "RemainAfterExit")) {
718db961	96	int b;
6577c7ce	97
718db961 LP	98	r = sd_bus_message_read(message, "b", &b);
	99	if (r < 0)
	100	return r;
6577c7ce	101
718db961	102	if (mode != UNIT_CHECK) {
6577c7ce LP	103	s->remain_after_exit = b;
	104	unit_write_drop_in_private_format(UNIT(s), mode, name, "RemainAfterExit=%s\n", yes_no(b));
	105	}
	106
	107	return 1;
	108
c7040b5d LP	109	} else if (streq(name, "Type")) {
	110	const char *t;
	111	ServiceType k;
	112
	113	r = sd_bus_message_read(message, "s", &t);
	114	if (r < 0)
	115	return r;
	116
	117	k = service_type_from_string(t);
	118	if (k < 0)
	119	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid service type %s", t);
	120
	121	if (mode != UNIT_CHECK) {
	122	s->type = k;
	123	unit_write_drop_in_private_format(UNIT(s), mode, name, "Type=%s\n", service_type_to_string(s->type));
	124	}
	125
	126	return 1;
	127
a34ceba6 LP	128	} else if (STR_IN_SET(name,
	129	"StandardInputFileDescriptor",
	130	"StandardOutputFileDescriptor",
	131	"StandardErrorFileDescriptor")) {
	132	int fd;
	133
	134	r = sd_bus_message_read(message, "h", &fd);
	135	if (r < 0)
	136	return r;
	137
	138	if (mode != UNIT_CHECK) {
	139	int copy;
	140
	141	copy = fcntl(fd, F_DUPFD_CLOEXEC, 3);
	142	if (copy < 0)
	143	return -errno;
	144
	145	if (streq(name, "StandardInputFileDescriptor")) {
	146	asynchronous_close(s->stdin_fd);
	147	s->stdin_fd = copy;
	148	} else if (streq(name, "StandardOutputFileDescriptor")) {
	149	asynchronous_close(s->stdout_fd);
	150	s->stdout_fd = copy;
	151	} else {
	152	asynchronous_close(s->stderr_fd);
	153	s->stderr_fd = copy;
	154	}
	155	}
	156
	157	return 1;
	158
6577c7ce	159	} else if (streq(name, "ExecStart")) {
c2756a68 LP	160	unsigned n = 0;
c2756a68 LP	161
718db961 LP	162	r = sd_bus_message_enter_container(message, 'a', "(sasb)");
	163	if (r < 0)
	164	return r;
c2756a68	165
718db961	166	while ((r = sd_bus_message_enter_container(message, 'r', "sasb")) > 0) {
c2756a68	167	_cleanup_strv_free_ char **argv = NULL;
c2756a68	168	const char *path;
718db961	169	int b;
c2756a68	170
718db961 LP	171	r = sd_bus_message_read(message, "s", &path);
	172	if (r < 0)
	173	return r;
c2756a68	174
718db961 LP	175	if (!path_is_absolute(path))
718db961 LP	176	return sd_bus_error_set_errnof(error, EINVAL, "Path %s is not absolute.", path);
c2756a68	177
718db961	178	r = sd_bus_message_read_strv(message, &argv);
c2756a68 LP	179	if (r < 0)
	180	return r;
	181
718db961 LP	182	r = sd_bus_message_read(message, "b", &b);
	183	if (r < 0)
	184	return r;
c2756a68	185
718db961 LP	186	r = sd_bus_message_exit_container(message);
	187	if (r < 0)
	188	return r;
c2756a68 LP	189
	190	if (mode != UNIT_CHECK) {
	191	ExecCommand *c;
	192
	193	c = new0(ExecCommand, 1);
	194	if (!c)
	195	return -ENOMEM;
	196
	197	c->path = strdup(path);
	198	if (!c->path) {
	199	free(c);
	200	return -ENOMEM;
	201	}
	202
	203	c->argv = argv;
	204	argv = NULL;
	205
718db961	206	c->ignore = b;
c2756a68 LP	207
	208	path_kill_slashes(c->path);
	209	exec_command_append_list(&s->exec_command[SERVICE_EXEC_START], c);
	210	}
	211
	212	n++;
c2756a68	213	}
c7040b5d	214
718db961 LP	215	if (r < 0)
718db961 LP	216	return r;
c2756a68	217
6ce270b1 LP	218	r = sd_bus_message_exit_container(message);
	219	if (r < 0)
	220	return r;
	221
c2756a68 LP	222	if (mode != UNIT_CHECK) {
	223	_cleanup_free_ char *buf = NULL;
	224	_cleanup_fclose_ FILE *f = NULL;
	225	ExecCommand *c;
	226	size_t size = 0;
	227
f1acf85a ZJS	228	if (n == 0)
f1acf85a ZJS	229	s->exec_command[SERVICE_EXEC_START] = exec_command_free_list(s->exec_command[SERVICE_EXEC_START]);
c2756a68 LP	230
	231	f = open_memstream(&buf, &size);
	232	if (!f)
	233	return -ENOMEM;
	234
	235	fputs("ExecStart=\n", f);
	236
	237	LIST_FOREACH(command, c, s->exec_command[SERVICE_EXEC_START]) {
a6fde353	238	_cleanup_free_ char *a;
c2756a68	239
a6fde353 ZJS	240	a = strv_join_quoted(c->argv);
	241	if (!a)
	242	return -ENOMEM;
c2756a68	243
a6fde353 ZJS	244	fprintf(f, "ExecStart=%s@%s %s\n",
	245	c->ignore ? "-" : "",
	246	c->path,
	247	a);
c2756a68 LP	248	}
c2756a68 LP	249
1f2f874c NC	250	r = fflush_and_check(f);
	251	if (r < 0)
	252	return r;
b9ec9359	253	unit_write_drop_in_private(UNIT(s), mode, name, buf);
c2756a68 LP	254	}
	255
	256	return 1;
	257	}
	258
	259	return 0;
	260	}
	261
74c964d3 LP	262	int bus_service_set_property(
	263	Unit *u,
	264	const char *name,
718db961	265	sd_bus_message *message,
74c964d3	266	UnitSetPropertiesMode mode,
718db961	267	sd_bus_error *error) {
74c964d3 LP	268
	269	Service *s = SERVICE(u);
	270	int r;
	271
718db961	272	assert(s);
74c964d3	273	assert(name);
718db961	274	assert(message);
74c964d3	275
718db961	276	r = bus_cgroup_set_property(u, &s->cgroup_context, name, message, mode, error);
74c964d3 LP	277	if (r != 0)
	278	return r;
	279
c2756a68 LP	280	if (u->transient && u->load_state == UNIT_STUB) {
	281	/* This is a transient unit, let's load a little more */
	282
718db961	283	r = bus_service_set_transient_property(s, name, message, mode, error);
c2756a68 LP	284	if (r != 0)
c2756a68 LP	285	return r;
a6c0353b	286
c7040b5d LP	287	r = bus_exec_context_set_transient_property(u, &s->exec_context, name, message, mode, error);
	288	if (r != 0)
	289	return r;
	290
718db961	291	r = bus_kill_context_set_transient_property(u, &s->kill_context, name, message, mode, error);
a6c0353b LP	292	if (r != 0)
a6c0353b LP	293	return r;
c2756a68 LP	294	}
c2756a68 LP	295
74c964d3 LP	296	return 0;
	297	}
	298
	299	int bus_service_commit_properties(Unit *u) {
	300	assert(u);
	301
bc432dc7	302	unit_update_cgroup_members_masks(u);
74c964d3	303	unit_realize_cgroup(u);
bc432dc7	304
74c964d3 LP	305	return 0;
74c964d3 LP	306	}