chiark / gitweb /
udev: support ENV{}=="" global property matches
[elogind.git] / src / core / dbus-scope.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2013 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 "unit.h"
23 #include "scope.h"
24 #include "dbus-unit.h"
25 #include "dbus-cgroup.h"
26 #include "dbus-kill.h"
27 #include "dbus-scope.h"
28 #include "dbus.h"
29 #include "bus-util.h"
30 #include "bus-internal.h"
31 #include "bus-errors.h"
32
33 static int bus_scope_abandon(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
34         Scope *s = userdata;
35         int r;
36
37         assert(bus);
38         assert(message);
39         assert(s);
40
41         r = bus_verify_manage_unit_async(UNIT(s)->manager, message, error);
42         if (r < 0)
43                 return r;
44         if (r == 0)
45                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
46
47         r = scope_abandon(s);
48         if (sd_bus_error_is_set(error))
49                 return r;
50
51         if (r == -ESTALE)
52                 return sd_bus_error_setf(error, BUS_ERROR_SCOPE_NOT_RUNNING, "Scope %s is not running, cannot abandon.", UNIT(s)->id);
53
54         return sd_bus_reply_method_return(message, NULL);
55 }
56
57 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_result, scope_result, ScopeResult);
58
59 const sd_bus_vtable bus_scope_vtable[] = {
60         SD_BUS_VTABLE_START(0),
61         SD_BUS_PROPERTY("Controller", "s", NULL, offsetof(Scope, controller), SD_BUS_VTABLE_PROPERTY_CONST),
62         SD_BUS_PROPERTY("TimeoutStopUSec", "t", bus_property_get_usec, offsetof(Scope, timeout_stop_usec), SD_BUS_VTABLE_PROPERTY_CONST),
63         SD_BUS_PROPERTY("Result", "s", property_get_result, offsetof(Scope, result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
64         SD_BUS_SIGNAL("RequestStop", NULL, 0),
65         SD_BUS_METHOD("Abandon", NULL, NULL, bus_scope_abandon, 0),
66         SD_BUS_VTABLE_END
67 };
68
69 static int bus_scope_set_transient_property(
70                 Scope *s,
71                 const char *name,
72                 sd_bus_message *message,
73                 UnitSetPropertiesMode mode,
74                 sd_bus_error *error) {
75
76         int r;
77
78         assert(s);
79         assert(name);
80         assert(message);
81
82         if (streq(name, "PIDs")) {
83                 unsigned n = 0;
84                 uint32_t pid;
85
86                 r = sd_bus_message_enter_container(message, 'a', "u");
87                 if (r < 0)
88                         return r;
89
90                 while ((r = sd_bus_message_read(message, "u", &pid)) > 0) {
91
92                         if (pid <= 1)
93                                 return -EINVAL;
94
95                         if (mode != UNIT_CHECK) {
96                                 r = unit_watch_pid(UNIT(s), pid);
97                                 if (r < 0 && r != -EEXIST)
98                                         return r;
99                         }
100
101                         n++;
102                 }
103                 if (r < 0)
104                         return r;
105
106                 r = sd_bus_message_exit_container(message);
107                 if (r < 0)
108                         return r;
109
110                 if (n <= 0)
111                         return -EINVAL;
112
113                 return 1;
114
115         } else if (streq(name, "Controller")) {
116                 const char *controller;
117                 char *c;
118
119                 r = sd_bus_message_read(message, "s", &controller);
120                 if (r < 0)
121                         return r;
122
123                 if (!isempty(controller) && !service_name_is_valid(controller))
124                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Controller '%s' is not a valid bus name.", controller);
125
126                 if (mode != UNIT_CHECK) {
127                         if (isempty(controller))
128                                 c = NULL;
129                         else {
130                                 c = strdup(controller);
131                                 if (!c)
132                                         return -ENOMEM;
133                         }
134
135                         free(s->controller);
136                         s->controller = c;
137                 }
138
139                 return 1;
140
141         } else if (streq(name, "TimeoutStopUSec")) {
142
143                 if (mode != UNIT_CHECK) {
144                         r = sd_bus_message_read(message, "t", &s->timeout_stop_usec);
145                         if (r < 0)
146                                 return r;
147
148                         unit_write_drop_in_format(UNIT(s), mode, name, "[Scope]\nTimeoutStopSec="USEC_FMT"us\n", s->timeout_stop_usec);
149                 } else {
150                         r = sd_bus_message_skip(message, "t");
151                         if (r < 0)
152                                 return r;
153                 }
154
155                 return 1;
156         }
157
158         return 0;
159 }
160
161 int bus_scope_set_property(
162                 Unit *u,
163                 const char *name,
164                 sd_bus_message *message,
165                 UnitSetPropertiesMode mode,
166                 sd_bus_error *error) {
167
168         Scope *s = SCOPE(u);
169         int r;
170
171         assert(s);
172         assert(name);
173         assert(message);
174
175         r = bus_cgroup_set_property(u, &s->cgroup_context, name, message, mode, error);
176         if (r != 0)
177                 return r;
178
179         if (u->load_state == UNIT_STUB) {
180                 /* While we are created we still accept PIDs */
181
182                 r = bus_scope_set_transient_property(s, name, message, mode, error);
183                 if (r != 0)
184                         return r;
185
186                 r = bus_kill_context_set_transient_property(u, &s->kill_context, name, message, mode, error);
187                 if (r != 0)
188                         return r;
189         }
190
191         return 0;
192 }
193
194 int bus_scope_commit_properties(Unit *u) {
195         assert(u);
196
197         unit_update_cgroup_members_masks(u);
198         unit_realize_cgroup(u);
199
200         return 0;
201 }
202
203 int bus_scope_send_request_stop(Scope *s) {
204         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
205         _cleanup_free_ char *p = NULL;
206         int r;
207
208         assert(s);
209
210         if (!s->controller)
211                 return 0;
212
213         p = unit_dbus_path(UNIT(s));
214         if (!p)
215                 return -ENOMEM;
216
217         r = sd_bus_message_new_signal(
218                         UNIT(s)->manager->api_bus,
219                         &m,
220                         p,
221                         "org.freedesktop.systemd1.Scope",
222                         "RequestStop");
223         if (r < 0)
224                 return r;
225
226         return sd_bus_send_to(UNIT(s)->manager->api_bus, m, /* s->controller */ NULL, NULL);
227 }