chiark / gitweb /
core: refuse doing %h, %s, %U specifier resolving in PID 1
[elogind.git] / src / core / dbus-service.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
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
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
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
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include "strv.h"
23 #include "path-util.h"
24 #include "unit.h"
25 #include "service.h"
26 #include "dbus-unit.h"
27 #include "dbus-execute.h"
28 #include "dbus-kill.h"
29 #include "dbus-cgroup.h"
30 #include "dbus-service.h"
31 #include "bus-util.h"
32
33 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_type, service_type, ServiceType);
34 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_result, service_result, ServiceResult);
35 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_restart, service_restart, ServiceRestart);
36 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_notify_access, notify_access, NotifyAccess);
37 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_start_limit_action, start_limit_action, StartLimitAction);
38
39 const sd_bus_vtable bus_service_vtable[] = {
40         SD_BUS_VTABLE_START(0),
41         SD_BUS_PROPERTY("Type", "s", property_get_type, offsetof(Service, type), 0),
42         SD_BUS_PROPERTY("Restart", "s", property_get_restart, offsetof(Service, restart), 0),
43         SD_BUS_PROPERTY("PIDFile", "s", NULL, offsetof(Service, pid_file), 0),
44         SD_BUS_PROPERTY("NotifyAccess", "s", property_get_notify_access, offsetof(Service, notify_access), 0),
45         SD_BUS_PROPERTY("RestartUSec", "t", bus_property_get_usec, offsetof(Service, restart_usec), 0),
46         SD_BUS_PROPERTY("TimeoutStartUSec", "t", bus_property_get_usec, offsetof(Service, timeout_start_usec), 0),
47         SD_BUS_PROPERTY("TimeoutStopUSec", "t", bus_property_get_usec, offsetof(Service, timeout_stop_usec), 0),
48         SD_BUS_PROPERTY("WatchdogUSec", "t", bus_property_get_usec, offsetof(Service, watchdog_usec), 0),
49         BUS_PROPERTY_DUAL_TIMESTAMP("WatchdogTimestamp", offsetof(Service, watchdog_timestamp), 0),
50         SD_BUS_PROPERTY("StartLimitInterval", "t", bus_property_get_usec, offsetof(Service, start_limit.interval), 0),
51         SD_BUS_PROPERTY("StartLimitBurst", "u", bus_property_get_unsigned, offsetof(Service, start_limit.burst), 0),
52         SD_BUS_PROPERTY("StartLimitAction", "s", property_get_start_limit_action, offsetof(Service, start_limit_action), 0),
53         SD_BUS_PROPERTY("PermissionsStartOnly", "b", bus_property_get_bool, offsetof(Service, permissions_start_only), 0),
54         SD_BUS_PROPERTY("RootDirectoryStartOnly", "b", bus_property_get_bool, offsetof(Service, root_directory_start_only), 0),
55         SD_BUS_PROPERTY("RemainAfterExit", "b", bus_property_get_bool, offsetof(Service, remain_after_exit), 0),
56         SD_BUS_PROPERTY("GuessMainPID", "b", bus_property_get_bool, offsetof(Service, guess_main_pid), 0),
57         SD_BUS_PROPERTY("MainPID", "u", bus_property_get_pid, offsetof(Service, main_pid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
58         SD_BUS_PROPERTY("ControlPID", "u", bus_property_get_pid, offsetof(Service, control_pid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
59         SD_BUS_PROPERTY("BusName", "s", NULL, offsetof(Service, bus_name), 0),
60         SD_BUS_PROPERTY("StatusText", "s", NULL, offsetof(Service, status_text), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
61         SD_BUS_PROPERTY("Result", "s", property_get_result, offsetof(Service, result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
62         BUS_EXEC_STATUS_VTABLE("ExecMain", offsetof(Service, main_exec_status), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
63         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStartPre", offsetof(Service, exec_command[SERVICE_EXEC_START_PRE]), 0),
64         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStart", offsetof(Service, exec_command[SERVICE_EXEC_START]), 0),
65         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStartPost", offsetof(Service, exec_command[SERVICE_EXEC_START_POST]), 0),
66         BUS_EXEC_COMMAND_LIST_VTABLE("ExecReload", offsetof(Service, exec_command[SERVICE_EXEC_RELOAD]), 0),
67         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStop", offsetof(Service, exec_command[SERVICE_EXEC_STOP]), 0),
68         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStopPost", offsetof(Service, exec_command[SERVICE_EXEC_STOP_POST]), 0),
69         SD_BUS_VTABLE_END
70 };
71
72 const char* const bus_service_changing_properties[] = {
73         "ExecMainStartTimestamp",
74         "ExecMainStartTimestampMonotonic",
75         "ExecMainExitTimestamp",
76         "ExecMainExitTimestampMonotonic",
77         "ExecMainPID",
78         "ExecMainCode",
79         "ExecMainStatus",
80         "MainPID",
81         "ControlPID",
82         "StatusText",
83         "Result",
84         NULL
85 };
86
87 static int bus_service_set_transient_property(
88                 Service *s,
89                 const char *name,
90                 sd_bus_message *message,
91                 UnitSetPropertiesMode mode,
92                 sd_bus_error *error) {
93
94         int r;
95
96         assert(s);
97         assert(name);
98         assert(message);
99
100         if (streq(name, "RemainAfterExit")) {
101                 int b;
102
103                 r = sd_bus_message_read(message, "b", &b);
104                 if (r < 0)
105                         return r;
106
107                 if (mode != UNIT_CHECK) {
108                         s->remain_after_exit = b;
109                         unit_write_drop_in_private_format(UNIT(s), mode, name, "RemainAfterExit=%s\n", yes_no(b));
110                 }
111
112                 return 1;
113
114         } else if (streq(name, "ExecStart")) {
115                 unsigned n = 0;
116
117                 r = sd_bus_message_enter_container(message, 'a', "(sasb)");
118                 if (r < 0)
119                         return r;
120
121                 while ((r = sd_bus_message_enter_container(message, 'r', "sasb")) > 0) {
122                         _cleanup_strv_free_ char **argv = NULL;
123                         const char *path;
124                         int b;
125
126                         r = sd_bus_message_read(message, "s", &path);
127                         if (r < 0)
128                                 return r;
129
130                         if (!path_is_absolute(path))
131                                 return sd_bus_error_set_errnof(error, EINVAL, "Path %s is not absolute.", path);
132
133                         r = sd_bus_message_read_strv(message, &argv);
134                         if (r < 0)
135                                 return r;
136
137                         r = sd_bus_message_read(message, "b", &b);
138                         if (r < 0)
139                                 return r;
140
141                         r = sd_bus_message_exit_container(message);
142                         if (r < 0)
143                                 return r;
144
145                         if (mode != UNIT_CHECK) {
146                                 ExecCommand *c;
147
148                                 c = new0(ExecCommand, 1);
149                                 if (!c)
150                                         return -ENOMEM;
151
152                                 c->path = strdup(path);
153                                 if (!c->path) {
154                                         free(c);
155                                         return -ENOMEM;
156                                 }
157
158                                 c->argv = argv;
159                                 argv = NULL;
160
161                                 c->ignore = b;
162
163                                 path_kill_slashes(c->path);
164                                 exec_command_append_list(&s->exec_command[SERVICE_EXEC_START], c);
165                         }
166
167                         n++;
168                 }
169                 if (r < 0)
170                         return r;
171
172                 r = sd_bus_message_exit_container(message);
173                 if (r < 0)
174                         return r;
175
176                 if (mode != UNIT_CHECK) {
177                         _cleanup_free_ char *buf = NULL;
178                         _cleanup_fclose_ FILE *f = NULL;
179                         ExecCommand *c;
180                         size_t size = 0;
181
182                         if (n == 0) {
183                                 exec_command_free_list(s->exec_command[SERVICE_EXEC_START]);
184                                 s->exec_command[SERVICE_EXEC_START] = NULL;
185                         }
186
187                         f = open_memstream(&buf, &size);
188                         if (!f)
189                                 return -ENOMEM;
190
191                         fputs("ExecStart=\n", f);
192
193                         LIST_FOREACH(command, c, s->exec_command[SERVICE_EXEC_START]) {
194                                 _cleanup_free_ char *a;
195
196                                 a = strv_join_quoted(c->argv);
197                                 if (!a)
198                                         return -ENOMEM;
199
200                                 fprintf(f, "ExecStart=%s@%s %s\n",
201                                         c->ignore ? "-" : "",
202                                         c->path,
203                                         a);
204                         }
205
206                         fflush(f);
207                         unit_write_drop_in_private(UNIT(s), mode, name, buf);
208                 }
209
210                 return 1;
211         }
212
213         return 0;
214 }
215
216 int bus_service_set_property(
217                 Unit *u,
218                 const char *name,
219                 sd_bus_message *message,
220                 UnitSetPropertiesMode mode,
221                 sd_bus_error *error) {
222
223         Service *s = SERVICE(u);
224         int r;
225
226         assert(s);
227         assert(name);
228         assert(message);
229
230         r = bus_cgroup_set_property(u, &s->cgroup_context, name, message, mode, error);
231         if (r != 0)
232                 return r;
233
234         if (u->transient && u->load_state == UNIT_STUB) {
235                 /* This is a transient unit, let's load a little more */
236
237                 r = bus_service_set_transient_property(s, name, message, mode, error);
238                 if (r != 0)
239                         return r;
240
241                 r = bus_kill_context_set_transient_property(u, &s->kill_context, name, message, mode, error);
242                 if (r != 0)
243                         return r;
244         }
245
246         return 0;
247 }
248
249 int bus_service_commit_properties(Unit *u) {
250         assert(u);
251
252         unit_realize_cgroup(u);
253         return 0;
254 }