Branch data Line data Source code
1 : : /* SPDX-License-Identifier: LGPL-2.1+ */
2 : :
3 : : #include "alloc-util.h"
4 : : #include "btrfs-util.h"
5 : : #include "bus-common-errors.h"
6 : : #include "bus-util.h"
7 : : #include "fd-util.h"
8 : : #include "io-util.h"
9 : : #include "machine-image.h"
10 : : #include "missing_capability.h"
11 : : #include "portable.h"
12 : : #include "portabled-bus.h"
13 : : #include "portabled-image-bus.h"
14 : : #include "portabled-image.h"
15 : : #include "portabled.h"
16 : : #include "strv.h"
17 : : #include "user-util.h"
18 : :
19 : 0 : static int property_get_pool_path(
20 : : sd_bus *bus,
21 : : const char *path,
22 : : const char *interface,
23 : : const char *property,
24 : : sd_bus_message *reply,
25 : : void *userdata,
26 : : sd_bus_error *error) {
27 : :
28 [ # # ]: 0 : assert(bus);
29 [ # # ]: 0 : assert(reply);
30 : :
31 : 0 : return sd_bus_message_append(reply, "s", "/var/lib/portables");
32 : : }
33 : :
34 : 0 : static int property_get_pool_usage(
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 : 0 : _cleanup_close_ int fd = -1;
44 : 0 : uint64_t usage = (uint64_t) -1;
45 : :
46 [ # # ]: 0 : assert(bus);
47 [ # # ]: 0 : assert(reply);
48 : :
49 : 0 : fd = open("/var/lib/portables", O_RDONLY|O_CLOEXEC|O_DIRECTORY);
50 [ # # ]: 0 : if (fd >= 0) {
51 : : BtrfsQuotaInfo q;
52 : :
53 [ # # ]: 0 : if (btrfs_subvol_get_subtree_quota_fd(fd, 0, &q) >= 0)
54 : 0 : usage = q.referenced;
55 : : }
56 : :
57 : 0 : return sd_bus_message_append(reply, "t", usage);
58 : : }
59 : :
60 : 0 : static int property_get_pool_limit(
61 : : sd_bus *bus,
62 : : const char *path,
63 : : const char *interface,
64 : : const char *property,
65 : : sd_bus_message *reply,
66 : : void *userdata,
67 : : sd_bus_error *error) {
68 : :
69 : 0 : _cleanup_close_ int fd = -1;
70 : 0 : uint64_t size = (uint64_t) -1;
71 : :
72 [ # # ]: 0 : assert(bus);
73 [ # # ]: 0 : assert(reply);
74 : :
75 : 0 : fd = open("/var/lib/portables", O_RDONLY|O_CLOEXEC|O_DIRECTORY);
76 [ # # ]: 0 : if (fd >= 0) {
77 : : BtrfsQuotaInfo q;
78 : :
79 [ # # ]: 0 : if (btrfs_subvol_get_subtree_quota_fd(fd, 0, &q) >= 0)
80 : 0 : size = q.referenced_max;
81 : : }
82 : :
83 : 0 : return sd_bus_message_append(reply, "t", size);
84 : : }
85 : :
86 : 0 : static int property_get_profiles(
87 : : sd_bus *bus,
88 : : const char *path,
89 : : const char *interface,
90 : : const char *property,
91 : : sd_bus_message *reply,
92 : : void *userdata,
93 : : sd_bus_error *error) {
94 : :
95 : 0 : _cleanup_strv_free_ char **l = NULL;
96 : : int r;
97 : :
98 [ # # ]: 0 : assert(bus);
99 [ # # ]: 0 : assert(reply);
100 : :
101 : 0 : r = portable_get_profiles(&l);
102 [ # # ]: 0 : if (r < 0)
103 : 0 : return r;
104 : :
105 : 0 : return sd_bus_message_append_strv(reply, l);
106 : : }
107 : :
108 : 0 : static int method_get_image(sd_bus_message *message, void *userdata, sd_bus_error *error) {
109 : 0 : _cleanup_free_ char *p = NULL;
110 : 0 : Manager *m = userdata;
111 : : const char *name;
112 : : Image *image;
113 : : int r;
114 : :
115 [ # # ]: 0 : assert(message);
116 [ # # ]: 0 : assert(m);
117 : :
118 : 0 : r = sd_bus_message_read(message, "s", &name);
119 [ # # ]: 0 : if (r < 0)
120 : 0 : return r;
121 : :
122 : 0 : r = bus_image_acquire(m, message, name, NULL, BUS_IMAGE_REFUSE_BY_PATH, NULL, &image, error);
123 [ # # ]: 0 : if (r < 0)
124 : 0 : return r;
125 : :
126 : 0 : r = bus_image_path(image, &p);
127 [ # # ]: 0 : if (r < 0)
128 : 0 : return r;
129 : :
130 : 0 : return sd_bus_reply_method_return(message, "o", p);
131 : : }
132 : :
133 : 0 : static int method_list_images(sd_bus_message *message, void *userdata, sd_bus_error *error) {
134 : 0 : _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
135 : 0 : _cleanup_hashmap_free_ Hashmap *images = NULL;
136 : 0 : Manager *m = userdata;
137 : : Image *image;
138 : : Iterator i;
139 : : int r;
140 : :
141 [ # # ]: 0 : assert(message);
142 [ # # ]: 0 : assert(m);
143 : :
144 : 0 : images = hashmap_new(&image_hash_ops);
145 [ # # ]: 0 : if (!images)
146 : 0 : return -ENOMEM;
147 : :
148 : 0 : r = manager_image_cache_discover(m, images, error);
149 [ # # ]: 0 : if (r < 0)
150 : 0 : return r;
151 : :
152 : 0 : r = sd_bus_message_new_method_return(message, &reply);
153 [ # # ]: 0 : if (r < 0)
154 : 0 : return r;
155 : :
156 : 0 : r = sd_bus_message_open_container(reply, 'a', "(ssbtttso)");
157 [ # # ]: 0 : if (r < 0)
158 : 0 : return r;
159 : :
160 [ # # ]: 0 : HASHMAP_FOREACH(image, images, i) {
161 [ # # ]: 0 : _cleanup_(sd_bus_error_free) sd_bus_error error_state = SD_BUS_ERROR_NULL;
162 : 0 : PortableState state = _PORTABLE_STATE_INVALID;
163 [ # # ]: 0 : _cleanup_free_ char *p = NULL;
164 : :
165 : 0 : r = bus_image_path(image, &p);
166 [ # # ]: 0 : if (r < 0)
167 : 0 : return r;
168 : :
169 : 0 : r = portable_get_state(
170 : : sd_bus_message_get_bus(message),
171 : 0 : image->path,
172 : : 0,
173 : : &state,
174 : : &error_state);
175 [ # # ]: 0 : if (r < 0)
176 [ # # ]: 0 : log_debug_errno(r, "Failed to get state of image '%s', ignoring: %s",
177 : : image->path, bus_error_message(&error_state, r));
178 : :
179 : 0 : r = sd_bus_message_append(reply, "(ssbtttso)",
180 : 0 : image->name,
181 : 0 : image_type_to_string(image->type),
182 : 0 : image->read_only,
183 : 0 : image->crtime,
184 : 0 : image->mtime,
185 : 0 : image->usage,
186 : : portable_state_to_string(state),
187 : : p);
188 [ # # ]: 0 : if (r < 0)
189 : 0 : return r;
190 : : }
191 : :
192 : 0 : r = sd_bus_message_close_container(reply);
193 [ # # ]: 0 : if (r < 0)
194 : 0 : return r;
195 : :
196 : 0 : return sd_bus_send(NULL, reply, NULL);
197 : : }
198 : :
199 : 0 : static int redirect_method_to_image(
200 : : Manager *m,
201 : : sd_bus_message *message,
202 : : sd_bus_error *error,
203 : : int (*method)(Manager *m, sd_bus_message *message, const char *name_or_path, Image *image, sd_bus_error* error)) {
204 : :
205 : : const char *name_or_path;
206 : : int r;
207 : :
208 [ # # ]: 0 : assert(m);
209 [ # # ]: 0 : assert(message);
210 [ # # ]: 0 : assert(method);
211 : :
212 : 0 : r = sd_bus_message_read(message, "s", &name_or_path);
213 [ # # ]: 0 : if (r < 0)
214 : 0 : return r;
215 : :
216 : 0 : return method(m, message, name_or_path, NULL, error);
217 : : }
218 : :
219 : 0 : static int method_get_image_os_release(sd_bus_message *message, void *userdata, sd_bus_error *error) {
220 : 0 : return redirect_method_to_image(userdata, message, error, bus_image_common_get_os_release);
221 : : }
222 : :
223 : 0 : static int method_get_image_metadata(sd_bus_message *message, void *userdata, sd_bus_error *error) {
224 : 0 : return redirect_method_to_image(userdata, message, error, bus_image_common_get_metadata);
225 : : }
226 : :
227 : 0 : static int method_get_image_state(sd_bus_message *message, void *userdata, sd_bus_error *error) {
228 : : const char *name_or_path;
229 : : PortableState state;
230 : : int r;
231 : :
232 [ # # ]: 0 : assert(message);
233 : :
234 : 0 : r = sd_bus_message_read(message, "s", &name_or_path);
235 [ # # ]: 0 : if (r < 0)
236 : 0 : return r;
237 : :
238 : 0 : r = portable_get_state(
239 : : sd_bus_message_get_bus(message),
240 : : name_or_path,
241 : : 0,
242 : : &state,
243 : : error);
244 [ # # ]: 0 : if (r < 0)
245 : 0 : return r;
246 : :
247 : 0 : return sd_bus_reply_method_return(message, "s", portable_state_to_string(state));
248 : : }
249 : :
250 : 0 : static int method_attach_image(sd_bus_message *message, void *userdata, sd_bus_error *error) {
251 : 0 : return redirect_method_to_image(userdata, message, error, bus_image_common_attach);
252 : : }
253 : :
254 : 0 : static int method_detach_image(sd_bus_message *message, void *userdata, sd_bus_error *error) {
255 : 0 : PortableChange *changes = NULL;
256 : 0 : Manager *m = userdata;
257 : 0 : size_t n_changes = 0;
258 : : const char *name_or_path;
259 : : int r, runtime;
260 : :
261 [ # # ]: 0 : assert(message);
262 [ # # ]: 0 : assert(m);
263 : :
264 : : /* Note that we do not redirect detaching to the image object here, because we want to allow that users can
265 : : * detach already deleted images too, in case the user already deleted an image before properly detaching
266 : : * it. */
267 : :
268 : 0 : r = sd_bus_message_read(message, "sb", &name_or_path, &runtime);
269 [ # # ]: 0 : if (r < 0)
270 : 0 : return r;
271 : :
272 : 0 : r = bus_verify_polkit_async(
273 : : message,
274 : : CAP_SYS_ADMIN,
275 : : "org.freedesktop.portable1.attach-images",
276 : : NULL,
277 : : false,
278 : : UID_INVALID,
279 : : &m->polkit_registry,
280 : : error);
281 [ # # ]: 0 : if (r < 0)
282 : 0 : return r;
283 [ # # ]: 0 : if (r == 0)
284 : 0 : return 1; /* Will call us back */
285 : :
286 : 0 : r = portable_detach(
287 : : sd_bus_message_get_bus(message),
288 : : name_or_path,
289 [ # # ]: 0 : runtime ? PORTABLE_RUNTIME : 0,
290 : : &changes,
291 : : &n_changes,
292 : : error);
293 [ # # ]: 0 : if (r < 0)
294 : 0 : goto finish;
295 : :
296 : 0 : r = reply_portable_changes(message, changes, n_changes);
297 : :
298 : 0 : finish:
299 : 0 : portable_changes_free(changes, n_changes);
300 : 0 : return r;
301 : : }
302 : :
303 : 0 : static int method_remove_image(sd_bus_message *message, void *userdata, sd_bus_error *error) {
304 : 0 : return redirect_method_to_image(userdata, message, error, bus_image_common_remove);
305 : : }
306 : :
307 : 0 : static int method_mark_image_read_only(sd_bus_message *message, void *userdata, sd_bus_error *error) {
308 : 0 : return redirect_method_to_image(userdata, message, error, bus_image_common_mark_read_only);
309 : : }
310 : :
311 : 0 : static int method_set_image_limit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
312 : 0 : return redirect_method_to_image(userdata, message, error, bus_image_common_set_limit);
313 : : }
314 : :
315 : 0 : static int method_set_pool_limit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
316 : 0 : Manager *m = userdata;
317 : : uint64_t limit;
318 : : int r;
319 : :
320 [ # # ]: 0 : assert(message);
321 : :
322 : 0 : r = sd_bus_message_read(message, "t", &limit);
323 [ # # ]: 0 : if (r < 0)
324 : 0 : return r;
325 [ # # ]: 0 : if (!FILE_SIZE_VALID_OR_INFINITY(limit))
326 : 0 : return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "New limit out of range");
327 : :
328 : 0 : r = bus_verify_polkit_async(
329 : : message,
330 : : CAP_SYS_ADMIN,
331 : : "org.freedesktop.portable1.manage-images",
332 : : NULL,
333 : : false,
334 : : UID_INVALID,
335 : : &m->polkit_registry,
336 : : error);
337 [ # # ]: 0 : if (r < 0)
338 : 0 : return r;
339 [ # # ]: 0 : if (r == 0)
340 : 0 : return 1; /* Will call us back */
341 : :
342 : 0 : (void) btrfs_qgroup_set_limit("/var/lib/portables", 0, limit);
343 : :
344 : 0 : r = btrfs_subvol_set_subtree_quota_limit("/var/lib/portables", 0, limit);
345 [ # # ]: 0 : if (r == -ENOTTY)
346 : 0 : return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Quota is only supported on btrfs.");
347 [ # # ]: 0 : if (r < 0)
348 : 0 : return sd_bus_error_set_errnof(error, r, "Failed to adjust quota limit: %m");
349 : :
350 : 0 : return sd_bus_reply_method_return(message, NULL);
351 : : }
352 : :
353 : : const sd_bus_vtable manager_vtable[] = {
354 : : SD_BUS_VTABLE_START(0),
355 : : SD_BUS_PROPERTY("PoolPath", "s", property_get_pool_path, 0, 0),
356 : : SD_BUS_PROPERTY("PoolUsage", "t", property_get_pool_usage, 0, 0),
357 : : SD_BUS_PROPERTY("PoolLimit", "t", property_get_pool_limit, 0, 0),
358 : : SD_BUS_PROPERTY("Profiles", "as", property_get_profiles, 0, 0),
359 : : SD_BUS_METHOD("GetImage", "s", "o", method_get_image, SD_BUS_VTABLE_UNPRIVILEGED),
360 : : SD_BUS_METHOD("ListImages", NULL, "a(ssbtttso)", method_list_images, SD_BUS_VTABLE_UNPRIVILEGED),
361 : : SD_BUS_METHOD("GetImageOSRelease", "s", "a{ss}", method_get_image_os_release, SD_BUS_VTABLE_UNPRIVILEGED),
362 : : SD_BUS_METHOD("GetImageMetadata", "sas", "saya{say}", method_get_image_metadata, SD_BUS_VTABLE_UNPRIVILEGED),
363 : : SD_BUS_METHOD("GetImageState", "s", "s", method_get_image_state, SD_BUS_VTABLE_UNPRIVILEGED),
364 : : SD_BUS_METHOD("AttachImage", "sassbs", "a(sss)", method_attach_image, SD_BUS_VTABLE_UNPRIVILEGED),
365 : : SD_BUS_METHOD("DetachImage", "sb", "a(sss)", method_detach_image, SD_BUS_VTABLE_UNPRIVILEGED),
366 : : SD_BUS_METHOD("RemoveImage", "s", NULL, method_remove_image, SD_BUS_VTABLE_UNPRIVILEGED),
367 : : SD_BUS_METHOD("MarkImageReadOnly", "sb", NULL, method_mark_image_read_only, SD_BUS_VTABLE_UNPRIVILEGED),
368 : : SD_BUS_METHOD("SetImageLimit", "st", NULL, method_set_image_limit, SD_BUS_VTABLE_UNPRIVILEGED),
369 : : SD_BUS_METHOD("SetPoolLimit", "t", NULL, method_set_pool_limit, SD_BUS_VTABLE_UNPRIVILEGED),
370 : : SD_BUS_VTABLE_END
371 : : };
372 : :
373 : 0 : int reply_portable_changes(sd_bus_message *m, const PortableChange *changes, size_t n_changes) {
374 : 0 : _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
375 : : size_t i;
376 : : int r;
377 : :
378 [ # # ]: 0 : assert(m);
379 [ # # # # ]: 0 : assert(changes || n_changes == 0);
380 : :
381 : 0 : r = sd_bus_message_new_method_return(m, &reply);
382 [ # # ]: 0 : if (r < 0)
383 : 0 : return r;
384 : :
385 : 0 : r = sd_bus_message_open_container(reply, 'a', "(sss)");
386 [ # # ]: 0 : if (r < 0)
387 : 0 : return r;
388 : :
389 [ # # ]: 0 : for (i = 0; i < n_changes; i++) {
390 : 0 : r = sd_bus_message_append(reply, "(sss)",
391 : 0 : portable_change_type_to_string(changes[i].type),
392 : 0 : changes[i].path,
393 : 0 : changes[i].source);
394 [ # # ]: 0 : if (r < 0)
395 : 0 : return r;
396 : : }
397 : :
398 : 0 : r = sd_bus_message_close_container(reply);
399 [ # # ]: 0 : if (r < 0)
400 : 0 : return r;
401 : :
402 : 0 : return sd_bus_send(NULL, reply, NULL);
403 : : }
|
