]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/machine/machined-dbus.c
projects / thirdparty / systemd.git / blob
? search:


2d9c180aa433c353b8a85f55459bf95d5f1517aa
[thirdparty/systemd.git] / src / machine / machined-dbus.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2
3 #include <errno.h>
4 #include <unistd.h>
5
6 #include "sd-id128.h"
7
8 #include "alloc-util.h"
9 #include "btrfs-util.h"
10 #include "bus-common-errors.h"
11 #include "bus-get-properties.h"
12 #include "bus-locator.h"
13 #include "bus-polkit.h"
14 #include "cgroup-util.h"
15 #include "errno-util.h"
16 #include "fd-util.h"
17 #include "fileio.h"
18 #include "format-util.h"
19 #include "hostname-util.h"
20 #include "image-dbus.h"
21 #include "io-util.h"
22 #include "machine-dbus.h"
23 #include "machine-image.h"
24 #include "machine-pool.h"
25 #include "machined.h"
26 #include "missing_capability.h"
27 #include "path-util.h"
28 #include "process-util.h"
29 #include "stdio-util.h"
30 #include "strv.h"
31 #include "tmpfile-util.h"
32 #include "unit-name.h"
33 #include "user-util.h"
34
35 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_pool_path, "s", "/var/lib/machines");
36
37 static int property_get_pool_usage(
38 sd_bus *bus,
39 const char *path,
40 const char *interface,
41 const char *property,
42 sd_bus_message *reply,
43 void *userdata,
44 sd_bus_error *error) {
45
46 _cleanup_close_ int fd = -1;
47 uint64_t usage = (uint64_t) -1;
48
49 assert(bus);
50 assert(reply);
51
52 fd = open("/var/lib/machines", O_RDONLY|O_CLOEXEC|O_DIRECTORY);
53 if (fd >= 0) {
54 BtrfsQuotaInfo q;
55
56 if (btrfs_subvol_get_subtree_quota_fd(fd, 0, &q) >= 0)
57 usage = q.referenced;
58 }
59
60 return sd_bus_message_append(reply, "t", usage);
61 }
62
63 static int property_get_pool_limit(
64 sd_bus *bus,
65 const char *path,
66 const char *interface,
67 const char *property,
68 sd_bus_message *reply,
69 void *userdata,
70 sd_bus_error *error) {
71
72 _cleanup_close_ int fd = -1;
73 uint64_t size = (uint64_t) -1;
74
75 assert(bus);
76 assert(reply);
77
78 fd = open("/var/lib/machines", O_RDONLY|O_CLOEXEC|O_DIRECTORY);
79 if (fd >= 0) {
80 BtrfsQuotaInfo q;
81
82 if (btrfs_subvol_get_subtree_quota_fd(fd, 0, &q) >= 0)
83 size = q.referenced_max;
84 }
85
86 return sd_bus_message_append(reply, "t", size);
87 }
88
89 static int method_get_machine(sd_bus_message *message, void *userdata, sd_bus_error *error) {
90 _cleanup_free_ char *p = NULL;
91 Manager *m = userdata;
92 Machine *machine;
93 const char *name;
94 int r;
95
96 assert(message);
97 assert(m);
98
99 r = sd_bus_message_read(message, "s", &name);
100 if (r < 0)
101 return r;
102
103 machine = hashmap_get(m->machines, name);
104 if (!machine)
105 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
106
107 p = machine_bus_path(machine);
108 if (!p)
109 return -ENOMEM;
110
111 return sd_bus_reply_method_return(message, "o", p);
112 }
113
114 static int method_get_image(sd_bus_message *message, void *userdata, sd_bus_error *error) {
115 _cleanup_free_ char *p = NULL;
116 _unused_ Manager *m = userdata;
117 const char *name;
118 int r;
119
120 assert(message);
121 assert(m);
122
123 r = sd_bus_message_read(message, "s", &name);
124 if (r < 0)
125 return r;
126
127 r = image_find(IMAGE_MACHINE, name, NULL);
128 if (r == -ENOENT)
129 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_IMAGE, "No image '%s' known", name);
130 if (r < 0)
131 return r;
132
133 p = image_bus_path(name);
134 if (!p)
135 return -ENOMEM;
136
137 return sd_bus_reply_method_return(message, "o", p);
138 }
139
140 static int method_get_machine_by_pid(sd_bus_message *message, void *userdata, sd_bus_error *error) {
141 _cleanup_free_ char *p = NULL;
142 Manager *m = userdata;
143 Machine *machine = NULL;
144 pid_t pid;
145 int r;
146
147 assert(message);
148 assert(m);
149
150 assert_cc(sizeof(pid_t) == sizeof(uint32_t));
151
152 r = sd_bus_message_read(message, "u", &pid);
153 if (r < 0)
154 return r;
155
156 if (pid < 0)
157 return -EINVAL;
158
159 if (pid == 0) {
160 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
161
162 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
163 if (r < 0)
164 return r;
165
166 r = sd_bus_creds_get_pid(creds, &pid);
167 if (r < 0)
168 return r;
169 }
170
171 r = manager_get_machine_by_pid(m, pid, &machine);
172 if (r < 0)
173 return r;
174 if (!machine)
175 return sd_bus_error_setf(error, BUS_ERROR_NO_MACHINE_FOR_PID, "PID "PID_FMT" does not belong to any known machine", pid);
176
177 p = machine_bus_path(machine);
178 if (!p)
179 return -ENOMEM;
180
181 return sd_bus_reply_method_return(message, "o", p);
182 }
183
184 static int method_list_machines(sd_bus_message *message, void *userdata, sd_bus_error *error) {
185 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
186 Manager *m = userdata;
187 Machine *machine;
188 Iterator i;
189 int r;
190
191 assert(message);
192 assert(m);
193
194 r = sd_bus_message_new_method_return(message, &reply);
195 if (r < 0)
196 return sd_bus_error_set_errno(error, r);
197
198 r = sd_bus_message_open_container(reply, 'a', "(ssso)");
199 if (r < 0)
200 return sd_bus_error_set_errno(error, r);
201
202 HASHMAP_FOREACH(machine, m->machines, i) {
203 _cleanup_free_ char *p = NULL;
204
205 p = machine_bus_path(machine);
206 if (!p)
207 return -ENOMEM;
208
209 r = sd_bus_message_append(reply, "(ssso)",
210 machine->name,
211 strempty(machine_class_to_string(machine->class)),
212 machine->service,
213 p);
214 if (r < 0)
215 return sd_bus_error_set_errno(error, r);
216 }
217
218 r = sd_bus_message_close_container(reply);
219 if (r < 0)
220 return sd_bus_error_set_errno(error, r);
221
222 return sd_bus_send(NULL, reply, NULL);
223 }
224
225 static int method_create_or_register_machine(Manager *manager, sd_bus_message *message, bool read_network, Machine **_m, sd_bus_error *error) {
226 const char *name, *service, *class, *root_directory;
227 const int32_t *netif = NULL;
228 MachineClass c;
229 uint32_t leader;
230 sd_id128_t id;
231 const void *v;
232 Machine *m;
233 size_t n, n_netif = 0;
234 int r;
235
236 assert(manager);
237 assert(message);
238 assert(_m);
239
240 r = sd_bus_message_read(message, "s", &name);
241 if (r < 0)
242 return r;
243 if (!machine_name_is_valid(name))
244 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid machine name");
245
246 r = sd_bus_message_read_array(message, 'y', &v, &n);
247 if (r < 0)
248 return r;
249 if (n == 0)
250 id = SD_ID128_NULL;
251 else if (n == 16)
252 memcpy(&id, v, n);
253 else
254 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid machine ID parameter");
255
256 r = sd_bus_message_read(message, "ssus", &service, &class, &leader, &root_directory);
257 if (r < 0)
258 return r;
259
260 if (read_network) {
261 size_t i;
262
263 r = sd_bus_message_read_array(message, 'i', (const void**) &netif, &n_netif);
264 if (r < 0)
265 return r;
266
267 n_netif /= sizeof(int32_t);
268
269 for (i = 0; i < n_netif; i++) {
270 if (netif[i] <= 0)
271 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid network interface index %i", netif[i]);
272 }
273 }
274
275 if (isempty(class))
276 c = _MACHINE_CLASS_INVALID;
277 else {
278 c = machine_class_from_string(class);
279 if (c < 0)
280 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid machine class parameter");
281 }
282
283 if (leader == 1)
284 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid leader PID");
285
286 if (!isempty(root_directory) && !path_is_absolute(root_directory))
287 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Root directory must be empty or an absolute path");
288
289 if (leader == 0) {
290 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
291
292 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
293 if (r < 0)
294 return r;
295
296 assert_cc(sizeof(uint32_t) == sizeof(pid_t));
297
298 r = sd_bus_creds_get_pid(creds, (pid_t*) &leader);
299 if (r < 0)
300 return r;
301 }
302
303 if (hashmap_get(manager->machines, name))
304 return sd_bus_error_setf(error, BUS_ERROR_MACHINE_EXISTS, "Machine '%s' already exists", name);
305
306 r = manager_add_machine(manager, name, &m);
307 if (r < 0)
308 return r;
309
310 m->leader = leader;
311 m->class = c;
312 m->id = id;
313
314 if (!isempty(service)) {
315 m->service = strdup(service);
316 if (!m->service) {
317 r = -ENOMEM;
318 goto fail;
319 }
320 }
321
322 if (!isempty(root_directory)) {
323 m->root_directory = strdup(root_directory);
324 if (!m->root_directory) {
325 r = -ENOMEM;
326 goto fail;
327 }
328 }
329
330 if (n_netif > 0) {
331 assert_cc(sizeof(int32_t) == sizeof(int));
332 m->netif = memdup(netif, sizeof(int32_t) * n_netif);
333 if (!m->netif) {
334 r = -ENOMEM;
335 goto fail;
336 }
337
338 m->n_netif = n_netif;
339 }
340
341 *_m = m;
342
343 return 1;
344
345 fail:
346 machine_add_to_gc_queue(m);
347 return r;
348 }
349
350 static int method_create_machine_internal(sd_bus_message *message, bool read_network, void *userdata, sd_bus_error *error) {
351 Manager *manager = userdata;
352 Machine *m = NULL;
353 int r;
354
355 assert(message);
356 assert(manager);
357
358 r = method_create_or_register_machine(manager, message, read_network, &m, error);
359 if (r < 0)
360 return r;
361
362 r = sd_bus_message_enter_container(message, 'a', "(sv)");
363 if (r < 0)
364 goto fail;
365
366 r = machine_start(m, message, error);
367 if (r < 0)
368 goto fail;
369
370 m->create_message = sd_bus_message_ref(message);
371 return 1;
372
373 fail:
374 machine_add_to_gc_queue(m);
375 return r;
376 }
377
378 static int method_create_machine_with_network(sd_bus_message *message, void *userdata, sd_bus_error *error) {
379 return method_create_machine_internal(message, true, userdata, error);
380 }
381
382 static int method_create_machine(sd_bus_message *message, void *userdata, sd_bus_error *error) {
383 return method_create_machine_internal(message, false, userdata, error);
384 }
385
386 static int method_register_machine_internal(sd_bus_message *message, bool read_network, void *userdata, sd_bus_error *error) {
387 Manager *manager = userdata;
388 _cleanup_free_ char *p = NULL;
389 Machine *m = NULL;
390 int r;
391
392 assert(message);
393 assert(manager);
394
395 r = method_create_or_register_machine(manager, message, read_network, &m, error);
396 if (r < 0)
397 return r;
398
399 r = cg_pid_get_unit(m->leader, &m->unit);
400 if (r < 0) {
401 r = sd_bus_error_set_errnof(error, r,
402 "Failed to determine unit of process "PID_FMT" : %m",
403 m->leader);
404 goto fail;
405 }
406
407 r = machine_start(m, NULL, error);
408 if (r < 0)
409 goto fail;
410
411 p = machine_bus_path(m);
412 if (!p) {
413 r = -ENOMEM;
414 goto fail;
415 }
416
417 return sd_bus_reply_method_return(message, "o", p);
418
419 fail:
420 machine_add_to_gc_queue(m);
421 return r;
422 }
423
424 static int method_register_machine_with_network(sd_bus_message *message, void *userdata, sd_bus_error *error) {
425 return method_register_machine_internal(message, true, userdata, error);
426 }
427
428 static int method_register_machine(sd_bus_message *message, void *userdata, sd_bus_error *error) {
429 return method_register_machine_internal(message, false, userdata, error);
430 }
431
432 static int redirect_method_to_machine(sd_bus_message *message, Manager *m, sd_bus_error *error, sd_bus_message_handler_t method) {
433 Machine *machine;
434 const char *name;
435 int r;
436
437 assert(message);
438 assert(m);
439 assert(method);
440
441 r = sd_bus_message_read(message, "s", &name);
442 if (r < 0)
443 return sd_bus_error_set_errno(error, r);
444
445 machine = hashmap_get(m->machines, name);
446 if (!machine)
447 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
448
449 return method(message, machine, error);
450 }
451
452 static int method_unregister_machine(sd_bus_message *message, void *userdata, sd_bus_error *error) {
453 return redirect_method_to_machine(message, userdata, error, bus_machine_method_unregister);
454 }
455
456 static int method_terminate_machine(sd_bus_message *message, void *userdata, sd_bus_error *error) {
457 return redirect_method_to_machine(message, userdata, error, bus_machine_method_terminate);
458 }
459
460 static int method_kill_machine(sd_bus_message *message, void *userdata, sd_bus_error *error) {
461 return redirect_method_to_machine(message, userdata, error, bus_machine_method_kill);
462 }
463
464 static int method_get_machine_addresses(sd_bus_message *message, void *userdata, sd_bus_error *error) {
465 return redirect_method_to_machine(message, userdata, error, bus_machine_method_get_addresses);
466 }
467
468 static int method_get_machine_os_release(sd_bus_message *message, void *userdata, sd_bus_error *error) {
469 return redirect_method_to_machine(message, userdata, error, bus_machine_method_get_os_release);
470 }
471
472 static int method_list_images(sd_bus_message *message, void *userdata, sd_bus_error *error) {
473 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
474 _cleanup_hashmap_free_ Hashmap *images = NULL;
475 _unused_ Manager *m = userdata;
476 Image *image;
477 Iterator i;
478 int r;
479
480 assert(message);
481 assert(m);
482
483 images = hashmap_new(&image_hash_ops);
484 if (!images)
485 return -ENOMEM;
486
487 r = image_discover(IMAGE_MACHINE, images);
488 if (r < 0)
489 return r;
490
491 r = sd_bus_message_new_method_return(message, &reply);
492 if (r < 0)
493 return r;
494
495 r = sd_bus_message_open_container(reply, 'a', "(ssbttto)");
496 if (r < 0)
497 return r;
498
499 HASHMAP_FOREACH(image, images, i) {
500 _cleanup_free_ char *p = NULL;
501
502 p = image_bus_path(image->name);
503 if (!p)
504 return -ENOMEM;
505
506 r = sd_bus_message_append(reply, "(ssbttto)",
507 image->name,
508 image_type_to_string(image->type),
509 image->read_only,
510 image->crtime,
511 image->mtime,
512 image->usage,
513 p);
514 if (r < 0)
515 return r;
516 }
517
518 r = sd_bus_message_close_container(reply);
519 if (r < 0)
520 return r;
521
522 return sd_bus_send(NULL, reply, NULL);
523 }
524
525 static int method_open_machine_pty(sd_bus_message *message, void *userdata, sd_bus_error *error) {
526 return redirect_method_to_machine(message, userdata, error, bus_machine_method_open_pty);
527 }
528
529 static int method_open_machine_login(sd_bus_message *message, void *userdata, sd_bus_error *error) {
530 return redirect_method_to_machine(message, userdata, error, bus_machine_method_open_login);
531 }
532
533 static int method_open_machine_shell(sd_bus_message *message, void *userdata, sd_bus_error *error) {
534 return redirect_method_to_machine(message, userdata, error, bus_machine_method_open_shell);
535 }
536
537 static int method_bind_mount_machine(sd_bus_message *message, void *userdata, sd_bus_error *error) {
538 return redirect_method_to_machine(message, userdata, error, bus_machine_method_bind_mount);
539 }
540
541 static int method_copy_machine(sd_bus_message *message, void *userdata, sd_bus_error *error) {
542 return redirect_method_to_machine(message, userdata, error, bus_machine_method_copy);
543 }
544
545 static int method_open_machine_root_directory(sd_bus_message *message, void *userdata, sd_bus_error *error) {
546 return redirect_method_to_machine(message, userdata, error, bus_machine_method_open_root_directory);
547 }
548
549 static int method_get_machine_uid_shift(sd_bus_message *message, void *userdata, sd_bus_error *error) {
550 return redirect_method_to_machine(message, userdata, error, bus_machine_method_get_uid_shift);
551 }
552
553 static int redirect_method_to_image(sd_bus_message *message, Manager *m, sd_bus_error *error, sd_bus_message_handler_t method) {
554 _cleanup_(image_unrefp) Image* i = NULL;
555 const char *name;
556 int r;
557
558 assert(message);
559 assert(m);
560 assert(method);
561
562 r = sd_bus_message_read(message, "s", &name);
563 if (r < 0)
564 return r;
565
566 if (!image_name_is_valid(name))
567 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Image name '%s' is invalid.", name);
568
569 r = image_find(IMAGE_MACHINE, name, &i);
570 if (r == -ENOENT)
571 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_IMAGE, "No image '%s' known", name);
572 if (r < 0)
573 return r;
574
575 i->userdata = m;
576 return method(message, i, error);
577 }
578
579 static int method_remove_image(sd_bus_message *message, void *userdata, sd_bus_error *error) {
580 return redirect_method_to_image(message, userdata, error, bus_image_method_remove);
581 }
582
583 static int method_rename_image(sd_bus_message *message, void *userdata, sd_bus_error *error) {
584 return redirect_method_to_image(message, userdata, error, bus_image_method_rename);
585 }
586
587 static int method_clone_image(sd_bus_message *message, void *userdata, sd_bus_error *error) {
588 return redirect_method_to_image(message, userdata, error, bus_image_method_clone);
589 }
590
591 static int method_mark_image_read_only(sd_bus_message *message, void *userdata, sd_bus_error *error) {
592 return redirect_method_to_image(message, userdata, error, bus_image_method_mark_read_only);
593 }
594
595 static int method_get_image_hostname(sd_bus_message *message, void *userdata, sd_bus_error *error) {
596 return redirect_method_to_image(message, userdata, error, bus_image_method_get_hostname);
597 }
598
599 static int method_get_image_machine_id(sd_bus_message *message, void *userdata, sd_bus_error *error) {
600 return redirect_method_to_image(message, userdata, error, bus_image_method_get_machine_id);
601 }
602
603 static int method_get_image_machine_info(sd_bus_message *message, void *userdata, sd_bus_error *error) {
604 return redirect_method_to_image(message, userdata, error, bus_image_method_get_machine_info);
605 }
606
607 static int method_get_image_os_release(sd_bus_message *message, void *userdata, sd_bus_error *error) {
608 return redirect_method_to_image(message, userdata, error, bus_image_method_get_os_release);
609 }
610
611 static int clean_pool_done(Operation *operation, int ret, sd_bus_error *error) {
612 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
613 _cleanup_fclose_ FILE *f = NULL;
614 bool success;
615 size_t n;
616 int r;
617
618 assert(operation);
619 assert(operation->extra_fd >= 0);
620
621 if (lseek(operation->extra_fd, 0, SEEK_SET) == (off_t) -1)
622 return -errno;
623
624 f = take_fdopen(&operation->extra_fd, "r");
625 if (!f)
626 return -errno;
627
628 /* The resulting temporary file starts with a boolean value that indicates success or not. */
629 errno = 0;
630 n = fread(&success, 1, sizeof(success), f);
631 if (n != sizeof(success))
632 return ret < 0 ? ret : errno_or_else(EIO);
633
634 if (ret < 0) {
635 _cleanup_free_ char *name = NULL;
636
637 /* The clean-up operation failed. In this case the resulting temporary file should contain a boolean
638 * set to false followed by the name of the failed image. Let's try to read this and use it for the
639 * error message. If we can't read it, don't mind, and return the naked error. */
640
641 if (success) /* The resulting temporary file could not be updated, ignore it. */
642 return ret;
643
644 r = read_nul_string(f, LONG_LINE_MAX, &name);
645 if (r <= 0) /* Same here... */
646 return ret;
647
648 return sd_bus_error_set_errnof(error, ret, "Failed to remove image %s: %m", name);
649 }
650
651 assert(success);
652
653 r = sd_bus_message_new_method_return(operation->message, &reply);
654 if (r < 0)
655 return r;
656
657 r = sd_bus_message_open_container(reply, 'a', "(st)");
658 if (r < 0)
659 return r;
660
661 /* On success the resulting temporary file will contain a list of image names that were removed followed by
662 * their size on disk. Let's read that and turn it into a bus message. */
663 for (;;) {
664 _cleanup_free_ char *name = NULL;
665 uint64_t size;
666
667 r = read_nul_string(f, LONG_LINE_MAX, &name);
668 if (r < 0)
669 return r;
670 if (r == 0) /* reached the end */
671 break;
672
673 errno = 0;
674 n = fread(&size, 1, sizeof(size), f);
675 if (n != sizeof(size))
676 return errno_or_else(EIO);
677
678 r = sd_bus_message_append(reply, "(st)", name, size);
679 if (r < 0)
680 return r;
681 }
682
683 r = sd_bus_message_close_container(reply);
684 if (r < 0)
685 return r;
686
687 return sd_bus_send(NULL, reply, NULL);
688 }
689
690 static int method_clean_pool(sd_bus_message *message, void *userdata, sd_bus_error *error) {
691 enum {
692 REMOVE_ALL,
693 REMOVE_HIDDEN,
694 } mode;
695
696 _cleanup_close_pair_ int errno_pipe_fd[2] = { -1, -1 };
697 _cleanup_close_ int result_fd = -1;
698 Manager *m = userdata;
699 Operation *operation;
700 const char *mm;
701 pid_t child;
702 int r;
703
704 assert(message);
705
706 if (m->n_operations >= OPERATIONS_MAX)
707 return sd_bus_error_setf(error, SD_BUS_ERROR_LIMITS_EXCEEDED, "Too many ongoing operations.");
708
709 r = sd_bus_message_read(message, "s", &mm);
710 if (r < 0)
711 return r;
712
713 if (streq(mm, "all"))
714 mode = REMOVE_ALL;
715 else if (streq(mm, "hidden"))
716 mode = REMOVE_HIDDEN;
717 else
718 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown mode '%s'.", mm);
719
720 r = bus_verify_polkit_async(
721 message,
722 CAP_SYS_ADMIN,
723 "org.freedesktop.machine1.manage-machines",
724 NULL,
725 false,
726 UID_INVALID,
727 &m->polkit_registry,
728 error);
729 if (r < 0)
730 return r;
731 if (r == 0)
732 return 1; /* Will call us back */
733
734 if (pipe2(errno_pipe_fd, O_CLOEXEC|O_NONBLOCK) < 0)
735 return sd_bus_error_set_errnof(error, errno, "Failed to create pipe: %m");
736
737 /* Create a temporary file we can dump information about deleted images into. We use a temporary file for this
738 * instead of a pipe or so, since this might grow quit large in theory and we don't want to process this
739 * continuously */
740 result_fd = open_tmpfile_unlinkable(NULL, O_RDWR|O_CLOEXEC);
741 if (result_fd < 0)
742 return -errno;
743
744 /* This might be a slow operation, run it asynchronously in a background process */
745 r = safe_fork("(sd-clean)", FORK_RESET_SIGNALS, &child);
746 if (r < 0)
747 return sd_bus_error_set_errnof(error, r, "Failed to fork(): %m");
748 if (r == 0) {
749 _cleanup_hashmap_free_ Hashmap *images = NULL;
750 bool success = true;
751 Image *image;
752 Iterator i;
753 ssize_t l;
754
755 errno_pipe_fd[0] = safe_close(errno_pipe_fd[0]);
756
757 images = hashmap_new(&image_hash_ops);
758 if (!images) {
759 r = -ENOMEM;
760 goto child_fail;
761 }
762
763 r = image_discover(IMAGE_MACHINE, images);
764 if (r < 0)
765 goto child_fail;
766
767 l = write(result_fd, &success, sizeof(success));
768 if (l < 0) {
769 r = -errno;
770 goto child_fail;
771 }
772
773 HASHMAP_FOREACH(image, images, i) {
774
775 /* We can't remove vendor images (i.e. those in /usr) */
776 if (IMAGE_IS_VENDOR(image))
777 continue;
778
779 if (IMAGE_IS_HOST(image))
780 continue;
781
782 if (mode == REMOVE_HIDDEN && !IMAGE_IS_HIDDEN(image))
783 continue;
784
785 r = image_remove(image);
786 if (r == -EBUSY) /* keep images that are currently being used. */
787 continue;
788 if (r < 0) {
789 /* If the operation failed, let's override everything we wrote, and instead write there at which image we failed. */
790 success = false;
791 (void) ftruncate(result_fd, 0);
792 (void) lseek(result_fd, 0, SEEK_SET);
793 (void) write(result_fd, &success, sizeof(success));
794 (void) write(result_fd, image->name, strlen(image->name)+1);
795 goto child_fail;
796 }
797
798 l = write(result_fd, image->name, strlen(image->name)+1);
799 if (l < 0) {
800 r = -errno;
801 goto child_fail;
802 }
803
804 l = write(result_fd, &image->usage_exclusive, sizeof(image->usage_exclusive));
805 if (l < 0) {
806 r = -errno;
807 goto child_fail;
808 }
809 }
810
811 result_fd = safe_close(result_fd);
812 _exit(EXIT_SUCCESS);
813
814 child_fail:
815 (void) write(errno_pipe_fd[1], &r, sizeof(r));
816 _exit(EXIT_FAILURE);
817 }
818
819 errno_pipe_fd[1] = safe_close(errno_pipe_fd[1]);
820
821 /* The clean-up might take a while, hence install a watch on the child and return */
822
823 r = operation_new(m, NULL, child, message, errno_pipe_fd[0], &operation);
824 if (r < 0) {
825 (void) sigkill_wait(child);
826 return r;
827 }
828
829 operation->extra_fd = result_fd;
830 operation->done = clean_pool_done;
831
832 result_fd = -1;
833 errno_pipe_fd[0] = -1;
834
835 return 1;
836 }
837
838 static int method_set_pool_limit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
839 Manager *m = userdata;
840 uint64_t limit;
841 int r;
842
843 assert(message);
844
845 r = sd_bus_message_read(message, "t", &limit);
846 if (r < 0)
847 return r;
848 if (!FILE_SIZE_VALID_OR_INFINITY(limit))
849 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "New limit out of range");
850
851 r = bus_verify_polkit_async(
852 message,
853 CAP_SYS_ADMIN,
854 "org.freedesktop.machine1.manage-machines",
855 NULL,
856 false,
857 UID_INVALID,
858 &m->polkit_registry,
859 error);
860 if (r < 0)
861 return r;
862 if (r == 0)
863 return 1; /* Will call us back */
864
865 /* Set up the machine directory if necessary */
866 r = setup_machine_directory(error);
867 if (r < 0)
868 return r;
869
870 (void) btrfs_qgroup_set_limit("/var/lib/machines", 0, limit);
871
872 r = btrfs_subvol_set_subtree_quota_limit("/var/lib/machines", 0, limit);
873 if (r == -ENOTTY)
874 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Quota is only supported on btrfs.");
875 if (r < 0)
876 return sd_bus_error_set_errnof(error, r, "Failed to adjust quota limit: %m");
877
878 return sd_bus_reply_method_return(message, NULL);
879 }
880
881 static int method_set_image_limit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
882 return redirect_method_to_image(message, userdata, error, bus_image_method_set_limit);
883 }
884
885 static int method_map_from_machine_user(sd_bus_message *message, void *userdata, sd_bus_error *error) {
886 _cleanup_fclose_ FILE *f = NULL;
887 Manager *m = userdata;
888 const char *name, *p;
889 Machine *machine;
890 uint32_t uid;
891 int r;
892
893 r = sd_bus_message_read(message, "su", &name, &uid);
894 if (r < 0)
895 return r;
896
897 if (!uid_is_valid(uid))
898 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid user ID " UID_FMT, uid);
899
900 machine = hashmap_get(m->machines, name);
901 if (!machine)
902 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
903
904 if (machine->class != MACHINE_CONTAINER)
905 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Not supported for non-container machines.");
906
907 p = procfs_file_alloca(machine->leader, "uid_map");
908 f = fopen(p, "re");
909 if (!f)
910 return -errno;
911
912 for (;;) {
913 uid_t uid_base, uid_shift, uid_range, converted;
914 int k;
915
916 errno = 0;
917 k = fscanf(f, UID_FMT " " UID_FMT " " UID_FMT, &uid_base, &uid_shift, &uid_range);
918 if (k < 0 && feof(f))
919 break;
920 if (k != 3) {
921 if (ferror(f))
922 return errno_or_else(EIO);
923
924 return -EIO;
925 }
926
927 if (uid < uid_base || uid >= uid_base + uid_range)
928 continue;
929
930 converted = uid - uid_base + uid_shift;
931 if (!uid_is_valid(converted))
932 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid user ID " UID_FMT, uid);
933
934 return sd_bus_reply_method_return(message, "u", (uint32_t) converted);
935 }
936
937 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_USER_MAPPING, "Machine '%s' has no matching user mappings.", name);
938 }
939
940 static int method_map_to_machine_user(sd_bus_message *message, void *userdata, sd_bus_error *error) {
941 Manager *m = userdata;
942 Machine *machine;
943 uid_t uid;
944 Iterator i;
945 int r;
946
947 r = sd_bus_message_read(message, "u", &uid);
948 if (r < 0)
949 return r;
950 if (!uid_is_valid(uid))
951 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid user ID " UID_FMT, uid);
952 if (uid < 0x10000)
953 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_USER_MAPPING, "User " UID_FMT " belongs to host UID range", uid);
954
955 HASHMAP_FOREACH(machine, m->machines, i) {
956 _cleanup_fclose_ FILE *f = NULL;
957 char p[STRLEN("/proc//uid_map") + DECIMAL_STR_MAX(pid_t) + 1];
958
959 if (machine->class != MACHINE_CONTAINER)
960 continue;
961
962 xsprintf(p, "/proc/" UID_FMT "/uid_map", machine->leader);
963 f = fopen(p, "re");
964 if (!f) {
965 log_warning_errno(errno, "Failed to open %s, ignoring,", p);
966 continue;
967 }
968
969 for (;;) {
970 _cleanup_free_ char *o = NULL;
971 uid_t uid_base, uid_shift, uid_range, converted;
972 int k;
973
974 errno = 0;
975 k = fscanf(f, UID_FMT " " UID_FMT " " UID_FMT, &uid_base, &uid_shift, &uid_range);
976 if (k < 0 && feof(f))
977 break;
978 if (k != 3) {
979 if (ferror(f))
980 return errno_or_else(EIO);
981
982 return -EIO;
983 }
984
985 /* The private user namespace is disabled, ignoring. */
986 if (uid_shift == 0)
987 continue;
988
989 if (uid < uid_shift || uid >= uid_shift + uid_range)
990 continue;
991
992 converted = (uid - uid_shift + uid_base);
993 if (!uid_is_valid(converted))
994 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid user ID " UID_FMT, uid);
995
996 o = machine_bus_path(machine);
997 if (!o)
998 return -ENOMEM;
999
1000 return sd_bus_reply_method_return(message, "sou", machine->name, o, (uint32_t) converted);
1001 }
1002 }
1003
1004 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_USER_MAPPING, "No matching user mapping for " UID_FMT ".", uid);
1005 }
1006
1007 static int method_map_from_machine_group(sd_bus_message *message, void *groupdata, sd_bus_error *error) {
1008 _cleanup_fclose_ FILE *f = NULL;
1009 Manager *m = groupdata;
1010 const char *name, *p;
1011 Machine *machine;
1012 uint32_t gid;
1013 int r;
1014
1015 r = sd_bus_message_read(message, "su", &name, &gid);
1016 if (r < 0)
1017 return r;
1018
1019 if (!gid_is_valid(gid))
1020 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid group ID " GID_FMT, gid);
1021
1022 machine = hashmap_get(m->machines, name);
1023 if (!machine)
1024 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
1025
1026 if (machine->class != MACHINE_CONTAINER)
1027 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Not supported for non-container machines.");
1028
1029 p = procfs_file_alloca(machine->leader, "gid_map");
1030 f = fopen(p, "re");
1031 if (!f)
1032 return -errno;
1033
1034 for (;;) {
1035 gid_t gid_base, gid_shift, gid_range, converted;
1036 int k;
1037
1038 errno = 0;
1039 k = fscanf(f, GID_FMT " " GID_FMT " " GID_FMT, &gid_base, &gid_shift, &gid_range);
1040 if (k < 0 && feof(f))
1041 break;
1042 if (k != 3) {
1043 if (ferror(f))
1044 return errno_or_else(EIO);
1045
1046 return -EIO;
1047 }
1048
1049 if (gid < gid_base || gid >= gid_base + gid_range)
1050 continue;
1051
1052 converted = gid - gid_base + gid_shift;
1053 if (!gid_is_valid(converted))
1054 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid group ID " GID_FMT, gid);
1055
1056 return sd_bus_reply_method_return(message, "u", (uint32_t) converted);
1057 }
1058
1059 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_GROUP_MAPPING, "Machine '%s' has no matching group mappings.", name);
1060 }
1061
1062 static int method_map_to_machine_group(sd_bus_message *message, void *groupdata, sd_bus_error *error) {
1063 Manager *m = groupdata;
1064 Machine *machine;
1065 gid_t gid;
1066 Iterator i;
1067 int r;
1068
1069 r = sd_bus_message_read(message, "u", &gid);
1070 if (r < 0)
1071 return r;
1072 if (!gid_is_valid(gid))
1073 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid group ID " GID_FMT, gid);
1074 if (gid < 0x10000)
1075 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_GROUP_MAPPING, "Group " GID_FMT " belongs to host GID range", gid);
1076
1077 HASHMAP_FOREACH(machine, m->machines, i) {
1078 _cleanup_fclose_ FILE *f = NULL;
1079 char p[STRLEN("/proc//gid_map") + DECIMAL_STR_MAX(pid_t) + 1];
1080
1081 if (machine->class != MACHINE_CONTAINER)
1082 continue;
1083
1084 xsprintf(p, "/proc/" GID_FMT "/gid_map", machine->leader);
1085 f = fopen(p, "re");
1086 if (!f) {
1087 log_warning_errno(errno, "Failed to open %s, ignoring,", p);
1088 continue;
1089 }
1090
1091 for (;;) {
1092 _cleanup_free_ char *o = NULL;
1093 gid_t gid_base, gid_shift, gid_range, converted;
1094 int k;
1095
1096 errno = 0;
1097 k = fscanf(f, GID_FMT " " GID_FMT " " GID_FMT, &gid_base, &gid_shift, &gid_range);
1098 if (k < 0 && feof(f))
1099 break;
1100 if (k != 3) {
1101 if (ferror(f))
1102 return errno_or_else(EIO);
1103
1104 return -EIO;
1105 }
1106
1107 /* The private user namespace is disabled, ignoring. */
1108 if (gid_shift == 0)
1109 continue;
1110
1111 if (gid < gid_shift || gid >= gid_shift + gid_range)
1112 continue;
1113
1114 converted = (gid - gid_shift + gid_base);
1115 if (!gid_is_valid(converted))
1116 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid group ID " GID_FMT, gid);
1117
1118 o = machine_bus_path(machine);
1119 if (!o)
1120 return -ENOMEM;
1121
1122 return sd_bus_reply_method_return(message, "sou", machine->name, o, (uint32_t) converted);
1123 }
1124 }
1125
1126 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_GROUP_MAPPING, "No matching group mapping for " GID_FMT ".", gid);
1127 }
1128
1129 const sd_bus_vtable manager_vtable[] = {
1130 SD_BUS_VTABLE_START(0),
1131
1132 SD_BUS_PROPERTY("PoolPath", "s", property_get_pool_path, 0, 0),
1133 SD_BUS_PROPERTY("PoolUsage", "t", property_get_pool_usage, 0, 0),
1134 SD_BUS_PROPERTY("PoolLimit", "t", property_get_pool_limit, 0, 0),
1135
1136 SD_BUS_METHOD_WITH_NAMES("GetMachine",
1137 "s",
1138 SD_BUS_PARAM(name),
1139 "o",
1140 SD_BUS_PARAM(machine),
1141 method_get_machine,
1142 SD_BUS_VTABLE_UNPRIVILEGED),
1143 SD_BUS_METHOD_WITH_NAMES("GetImage",
1144 "s",
1145 SD_BUS_PARAM(name),
1146 "o",
1147 SD_BUS_PARAM(image),
1148 method_get_image,
1149 SD_BUS_VTABLE_UNPRIVILEGED),
1150 SD_BUS_METHOD_WITH_NAMES("GetMachineByPID",
1151 "u",
1152 SD_BUS_PARAM(pid),
1153 "o",
1154 SD_BUS_PARAM(machine),
1155 method_get_machine_by_pid,
1156 SD_BUS_VTABLE_UNPRIVILEGED),
1157 SD_BUS_METHOD_WITH_NAMES("ListMachines",
1158 NULL,,
1159 "a(ssso)",
1160 SD_BUS_PARAM(machines),
1161 method_list_machines,
1162 SD_BUS_VTABLE_UNPRIVILEGED),
1163 SD_BUS_METHOD_WITH_NAMES("ListImages",
1164 NULL,,
1165 "a(ssbttto)",
1166 SD_BUS_PARAM(images),
1167 method_list_images,
1168 SD_BUS_VTABLE_UNPRIVILEGED),
1169 SD_BUS_METHOD_WITH_NAMES("CreateMachine",
1170 "sayssusa(sv)",
1171 SD_BUS_PARAM(name)
1172 SD_BUS_PARAM(id)
1173 SD_BUS_PARAM(service)
1174 SD_BUS_PARAM(class)
1175 SD_BUS_PARAM(leader)
1176 SD_BUS_PARAM(root_directory)
1177 SD_BUS_PARAM(scope_properties),
1178 "o",
1179 SD_BUS_PARAM(path),
1180 method_create_machine, 0),
1181 SD_BUS_METHOD_WITH_NAMES("CreateMachineWithNetwork",
1182 "sayssusaia(sv)",
1183 SD_BUS_PARAM(name)
1184 SD_BUS_PARAM(id)
1185 SD_BUS_PARAM(service)
1186 SD_BUS_PARAM(class)
1187 SD_BUS_PARAM(leader)
1188 SD_BUS_PARAM(root_directory)
1189 SD_BUS_PARAM(ifindices)
1190 SD_BUS_PARAM(scope_properties),
1191 "o",
1192 SD_BUS_PARAM(path),
1193 method_create_machine_with_network, 0),
1194 SD_BUS_METHOD_WITH_NAMES("RegisterMachine",
1195 "sayssus",
1196 SD_BUS_PARAM(name)
1197 SD_BUS_PARAM(id)
1198 SD_BUS_PARAM(service)
1199 SD_BUS_PARAM(class)
1200 SD_BUS_PARAM(leader)
1201 SD_BUS_PARAM(root_directory),
1202 "o",
1203 SD_BUS_PARAM(path),
1204 method_register_machine, 0),
1205 SD_BUS_METHOD_WITH_NAMES("RegisterMachineWithNetwork",
1206 "sayssusai",
1207 SD_BUS_PARAM(name)
1208 SD_BUS_PARAM(id)
1209 SD_BUS_PARAM(service)
1210 SD_BUS_PARAM(class)
1211 SD_BUS_PARAM(leader)
1212 SD_BUS_PARAM(root_directory)
1213 SD_BUS_PARAM(ifindices),
1214 "o",
1215 SD_BUS_PARAM(path),
1216 method_register_machine_with_network, 0),
1217 SD_BUS_METHOD_WITH_NAMES("UnregisterMachine",
1218 "s",
1219 SD_BUS_PARAM(name),
1220 NULL,,
1221 method_unregister_machine,
1222 SD_BUS_VTABLE_UNPRIVILEGED),
1223 SD_BUS_METHOD_WITH_NAMES("TerminateMachine",
1224 "s",
1225 SD_BUS_PARAM(id),
1226 NULL,,
1227 method_terminate_machine,
1228 SD_BUS_VTABLE_UNPRIVILEGED),
1229 SD_BUS_METHOD_WITH_NAMES("KillMachine",
1230 "ssi",
1231 SD_BUS_PARAM(name)
1232 SD_BUS_PARAM(who)
1233 SD_BUS_PARAM(signal),
1234 NULL,,
1235 method_kill_machine,
1236 SD_BUS_VTABLE_UNPRIVILEGED),
1237 SD_BUS_METHOD_WITH_NAMES("GetMachineAddresses",
1238 "s",
1239 SD_BUS_PARAM(name),
1240 "a(iay)",
1241 SD_BUS_PARAM(addresses),
1242 method_get_machine_addresses,
1243 SD_BUS_VTABLE_UNPRIVILEGED),
1244 SD_BUS_METHOD_WITH_NAMES("GetMachineOSRelease",
1245 "s",
1246 SD_BUS_PARAM(name),
1247 "a{ss}",
1248 SD_BUS_PARAM(fields),
1249 method_get_machine_os_release,
1250 SD_BUS_VTABLE_UNPRIVILEGED),
1251 SD_BUS_METHOD_WITH_NAMES("OpenMachinePTY",
1252 "s",
1253 SD_BUS_PARAM(name),
1254 "hs",
1255 SD_BUS_PARAM(pty)
1256 SD_BUS_PARAM(pty_path),
1257 method_open_machine_pty,
1258 0),
1259 SD_BUS_METHOD_WITH_NAMES("OpenMachineLogin",
1260 "s",
1261 SD_BUS_PARAM(name),
1262 "hs",
1263 SD_BUS_PARAM(pty)
1264 SD_BUS_PARAM(pty_path),
1265 method_open_machine_login,
1266 SD_BUS_VTABLE_UNPRIVILEGED),
1267 SD_BUS_METHOD_WITH_NAMES("OpenMachineShell",
1268 "sssasas",
1269 SD_BUS_PARAM(name)
1270 SD_BUS_PARAM(user)
1271 SD_BUS_PARAM(path)
1272 SD_BUS_PARAM(args)
1273 SD_BUS_PARAM(environment),
1274 "hs",
1275 SD_BUS_PARAM(pty)
1276 SD_BUS_PARAM(pty_path),
1277 method_open_machine_shell,
1278 SD_BUS_VTABLE_UNPRIVILEGED),
1279 SD_BUS_METHOD_WITH_NAMES("BindMountMachine",
1280 "sssbb",
1281 SD_BUS_PARAM(name)
1282 SD_BUS_PARAM(source)
1283 SD_BUS_PARAM(destination)
1284 SD_BUS_PARAM(read_only)
1285 SD_BUS_PARAM(mkdir),
1286 NULL,,
1287 method_bind_mount_machine,
1288 SD_BUS_VTABLE_UNPRIVILEGED),
1289 SD_BUS_METHOD_WITH_NAMES("CopyFromMachine",
1290 "sss",
1291 SD_BUS_PARAM(name)
1292 SD_BUS_PARAM(source)
1293 SD_BUS_PARAM(destination),
1294 NULL,,
1295 method_copy_machine,
1296 SD_BUS_VTABLE_UNPRIVILEGED),
1297 SD_BUS_METHOD_WITH_NAMES("CopyToMachine",
1298 "sss",
1299 SD_BUS_PARAM(name)
1300 SD_BUS_PARAM(source)
1301 SD_BUS_PARAM(destination),
1302 NULL,,
1303 method_copy_machine,
1304 SD_BUS_VTABLE_UNPRIVILEGED),
1305 SD_BUS_METHOD_WITH_NAMES("OpenMachineRootDirectory",
1306 "s",
1307 SD_BUS_PARAM(name),
1308 "h",
1309 SD_BUS_PARAM(fd),
1310 method_open_machine_root_directory,
1311 SD_BUS_VTABLE_UNPRIVILEGED),
1312 SD_BUS_METHOD_WITH_NAMES("GetMachineUIDShift",
1313 "s",
1314 SD_BUS_PARAM(name),
1315 "u",
1316 SD_BUS_PARAM(shift),
1317 method_get_machine_uid_shift,
1318 SD_BUS_VTABLE_UNPRIVILEGED),
1319 SD_BUS_METHOD_WITH_NAMES("RemoveImage",
1320 "s",
1321 SD_BUS_PARAM(name),
1322 NULL,,
1323 method_remove_image,
1324 SD_BUS_VTABLE_UNPRIVILEGED),
1325 SD_BUS_METHOD_WITH_NAMES("RenameImage",
1326 "ss",
1327 SD_BUS_PARAM(name)
1328 SD_BUS_PARAM(new_name),
1329 NULL,,
1330 method_rename_image,
1331 SD_BUS_VTABLE_UNPRIVILEGED),
1332 SD_BUS_METHOD_WITH_NAMES("CloneImage",
1333 "ssb",
1334 SD_BUS_PARAM(name)
1335 SD_BUS_PARAM(new_name)
1336 SD_BUS_PARAM(read_only),
1337 NULL,,
1338 method_clone_image,
1339 SD_BUS_VTABLE_UNPRIVILEGED),
1340 SD_BUS_METHOD_WITH_NAMES("MarkImageReadOnly",
1341 "sb",
1342 SD_BUS_PARAM(name)
1343 SD_BUS_PARAM(read_only),
1344 NULL,,
1345 method_mark_image_read_only,
1346 SD_BUS_VTABLE_UNPRIVILEGED),
1347 SD_BUS_METHOD_WITH_NAMES("GetImageHostname",
1348 "s",
1349 SD_BUS_PARAM(name),
1350 "s",
1351 SD_BUS_PARAM(hostname),
1352 method_get_image_hostname,
1353 SD_BUS_VTABLE_UNPRIVILEGED),
1354 SD_BUS_METHOD_WITH_NAMES("GetImageMachineID",
1355 "s",
1356 SD_BUS_PARAM(name),
1357 "ay",
1358 SD_BUS_PARAM(id),
1359 method_get_image_machine_id,
1360 SD_BUS_VTABLE_UNPRIVILEGED),
1361 SD_BUS_METHOD_WITH_NAMES("GetImageMachineInfo",
1362 "s",
1363 SD_BUS_PARAM(name),
1364 "a{ss}",
1365 SD_BUS_PARAM(machine_info),
1366 method_get_image_machine_info,
1367 SD_BUS_VTABLE_UNPRIVILEGED),
1368 SD_BUS_METHOD_WITH_NAMES("GetImageOSRelease",
1369 "s",
1370 SD_BUS_PARAM(name),
1371 "a{ss}",
1372 SD_BUS_PARAM(os_release),
1373 method_get_image_os_release,
1374 SD_BUS_VTABLE_UNPRIVILEGED),
1375 SD_BUS_METHOD_WITH_NAMES("SetPoolLimit",
1376 "t",
1377 SD_BUS_PARAM(size),
1378 NULL,,
1379 method_set_pool_limit,
1380 SD_BUS_VTABLE_UNPRIVILEGED),
1381 SD_BUS_METHOD_WITH_NAMES("SetImageLimit",
1382 "st",
1383 SD_BUS_PARAM(name)
1384 SD_BUS_PARAM(size),
1385 NULL,,
1386 method_set_image_limit,
1387 SD_BUS_VTABLE_UNPRIVILEGED),
1388 SD_BUS_METHOD_WITH_NAMES("CleanPool",
1389 "s",
1390 SD_BUS_PARAM(mode),
1391 "a(st)",
1392 SD_BUS_PARAM(images),
1393 method_clean_pool,
1394 SD_BUS_VTABLE_UNPRIVILEGED),
1395 SD_BUS_METHOD_WITH_NAMES("MapFromMachineUser",
1396 "su",
1397 SD_BUS_PARAM(name)
1398 SD_BUS_PARAM(uid_inner),
1399 "u",
1400 SD_BUS_PARAM(uid_outer),
1401 method_map_from_machine_user,
1402 SD_BUS_VTABLE_UNPRIVILEGED),
1403 SD_BUS_METHOD_WITH_NAMES("MapToMachineUser",
1404 "u",
1405 SD_BUS_PARAM(uid_outer),
1406 "sou",
1407 SD_BUS_PARAM(machine_name)
1408 SD_BUS_PARAM(machine_path)
1409 SD_BUS_PARAM(uid_inner),
1410 method_map_to_machine_user,
1411 SD_BUS_VTABLE_UNPRIVILEGED),
1412 SD_BUS_METHOD_WITH_NAMES("MapFromMachineGroup",
1413 "su",
1414 SD_BUS_PARAM(name)
1415 SD_BUS_PARAM(gid_inner),
1416 "u",
1417 SD_BUS_PARAM(gid_outer),
1418 method_map_from_machine_group,
1419 SD_BUS_VTABLE_UNPRIVILEGED),
1420 SD_BUS_METHOD_WITH_NAMES("MapToMachineGroup",
1421 "u",
1422 SD_BUS_PARAM(gid_outer),
1423 "sou",
1424 SD_BUS_PARAM(machine_name)
1425 SD_BUS_PARAM(machine_path)
1426 SD_BUS_PARAM(gid_inner),
1427 method_map_to_machine_group,
1428 SD_BUS_VTABLE_UNPRIVILEGED),
1429
1430 SD_BUS_SIGNAL_WITH_NAMES("MachineNew",
1431 "so",
1432 SD_BUS_PARAM(machine)
1433 SD_BUS_PARAM(path),
1434 0),
1435 SD_BUS_SIGNAL_WITH_NAMES("MachineRemoved",
1436 "so",
1437 SD_BUS_PARAM(machine)
1438 SD_BUS_PARAM(path),
1439 0),
1440
1441 SD_BUS_VTABLE_END
1442 };
1443
1444 const BusObjectImplementation manager_object = {
1445 "/org/freedesktop/machine1",
1446 "org.freedesktop.machine1.Manager",
1447 .vtables = BUS_VTABLES(manager_vtable),
1448 .children = BUS_IMPLEMENTATIONS( &machine_object,
1449 &image_object ),
1450 };
1451
1452 int match_job_removed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1453 const char *path, *result, *unit;
1454 Manager *m = userdata;
1455 Machine *machine;
1456 uint32_t id;
1457 int r;
1458
1459 assert(message);
1460 assert(m);
1461
1462 r = sd_bus_message_read(message, "uoss", &id, &path, &unit, &result);
1463 if (r < 0) {
1464 bus_log_parse_error(r);
1465 return 0;
1466 }
1467
1468 machine = hashmap_get(m->machine_units, unit);
1469 if (!machine)
1470 return 0;
1471
1472 if (streq_ptr(path, machine->scope_job)) {
1473 machine->scope_job = mfree(machine->scope_job);
1474
1475 if (machine->started) {
1476 if (streq(result, "done"))
1477 machine_send_create_reply(machine, NULL);
1478 else {
1479 _cleanup_(sd_bus_error_free) sd_bus_error e = SD_BUS_ERROR_NULL;
1480
1481 sd_bus_error_setf(&e, BUS_ERROR_JOB_FAILED, "Start job for unit %s failed with '%s'", unit, result);
1482
1483 machine_send_create_reply(machine, &e);
1484 }
1485 }
1486
1487 machine_save(machine);
1488 }
1489
1490 machine_add_to_gc_queue(machine);
1491 return 0;
1492 }
1493
1494 int match_properties_changed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1495 _cleanup_free_ char *unit = NULL;
1496 const char *path;
1497 Manager *m = userdata;
1498 Machine *machine;
1499 int r;
1500
1501 assert(message);
1502 assert(m);
1503
1504 path = sd_bus_message_get_path(message);
1505 if (!path)
1506 return 0;
1507
1508 r = unit_name_from_dbus_path(path, &unit);
1509 if (r == -EINVAL) /* not for a unit */
1510 return 0;
1511 if (r < 0) {
1512 log_oom();
1513 return 0;
1514 }
1515
1516 machine = hashmap_get(m->machine_units, unit);
1517 if (!machine)
1518 return 0;
1519
1520 machine_add_to_gc_queue(machine);
1521 return 0;
1522 }
1523
1524 int match_unit_removed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1525 const char *path, *unit;
1526 Manager *m = userdata;
1527 Machine *machine;
1528 int r;
1529
1530 assert(message);
1531 assert(m);
1532
1533 r = sd_bus_message_read(message, "so", &unit, &path);
1534 if (r < 0) {
1535 bus_log_parse_error(r);
1536 return 0;
1537 }
1538
1539 machine = hashmap_get(m->machine_units, unit);
1540 if (!machine)
1541 return 0;
1542
1543 machine_add_to_gc_queue(machine);
1544 return 0;
1545 }
1546
1547 int match_reloading(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1548 Manager *m = userdata;
1549 Machine *machine;
1550 Iterator i;
1551 int b, r;
1552
1553 assert(message);
1554 assert(m);
1555
1556 r = sd_bus_message_read(message, "b", &b);
1557 if (r < 0) {
1558 bus_log_parse_error(r);
1559 return 0;
1560 }
1561 if (b)
1562 return 0;
1563
1564 /* systemd finished reloading, let's recheck all our machines */
1565 log_debug("System manager has been reloaded, rechecking machines...");
1566
1567 HASHMAP_FOREACH(machine, m->machines, i)
1568 machine_add_to_gc_queue(machine);
1569
1570 return 0;
1571 }
1572
1573 int manager_unref_unit(
1574 Manager *m,
1575 const char *unit,
1576 sd_bus_error *error) {
1577
1578 assert(m);
1579 assert(unit);
1580
1581 return bus_call_method(m->bus, bus_systemd_mgr, "UnrefUnit", error, NULL, "s", unit);
1582 }
1583
1584 int manager_stop_unit(Manager *manager, const char *unit, sd_bus_error *error, char **job) {
1585 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1586 int r;
1587
1588 assert(manager);
1589 assert(unit);
1590
1591 r = bus_call_method(manager->bus, bus_systemd_mgr, "StopUnit", error, &reply, "ss", unit, "fail");
1592 if (r < 0) {
1593 if (sd_bus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT) ||
1594 sd_bus_error_has_name(error, BUS_ERROR_LOAD_FAILED)) {
1595
1596 if (job)
1597 *job = NULL;
1598
1599 sd_bus_error_free(error);
1600 return 0;
1601 }
1602
1603 return r;
1604 }
1605
1606 if (job) {
1607 const char *j;
1608 char *copy;
1609
1610 r = sd_bus_message_read(reply, "o", &j);
1611 if (r < 0)
1612 return r;
1613
1614 copy = strdup(j);
1615 if (!copy)
1616 return -ENOMEM;
1617
1618 *job = copy;
1619 }
1620
1621 return 1;
1622 }
1623
1624 int manager_kill_unit(Manager *manager, const char *unit, int signo, sd_bus_error *error) {
1625 assert(manager);
1626 assert(unit);
1627
1628 return bus_call_method(manager->bus, bus_systemd_mgr, "KillUnit", error, NULL, "ssi", unit, "all", signo);
1629 }
1630
1631 int manager_unit_is_active(Manager *manager, const char *unit) {
1632 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1633 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1634 _cleanup_free_ char *path = NULL;
1635 const char *state;
1636 int r;
1637
1638 assert(manager);
1639 assert(unit);
1640
1641 path = unit_dbus_path_from_name(unit);
1642 if (!path)
1643 return -ENOMEM;
1644
1645 r = sd_bus_get_property(
1646 manager->bus,
1647 "org.freedesktop.systemd1",
1648 path,
1649 "org.freedesktop.systemd1.Unit",
1650 "ActiveState",
1651 &error,
1652 &reply,
1653 "s");
1654 if (r < 0) {
1655 if (sd_bus_error_has_name(&error, SD_BUS_ERROR_NO_REPLY) ||
1656 sd_bus_error_has_name(&error, SD_BUS_ERROR_DISCONNECTED))
1657 return true;
1658
1659 if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_UNIT) ||
1660 sd_bus_error_has_name(&error, BUS_ERROR_LOAD_FAILED))
1661 return false;
1662
1663 return r;
1664 }
1665
1666 r = sd_bus_message_read(reply, "s", &state);
1667 if (r < 0)
1668 return -EINVAL;
1669
1670 return !STR_IN_SET(state, "inactive", "failed");
1671 }
1672
1673 int manager_job_is_active(Manager *manager, const char *path) {
1674 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1675 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1676 int r;
1677
1678 assert(manager);
1679 assert(path);
1680
1681 r = sd_bus_get_property(
1682 manager->bus,
1683 "org.freedesktop.systemd1",
1684 path,
1685 "org.freedesktop.systemd1.Job",
1686 "State",
1687 &error,
1688 &reply,
1689 "s");
1690 if (r < 0) {
1691 if (sd_bus_error_has_name(&error, SD_BUS_ERROR_NO_REPLY) ||
1692 sd_bus_error_has_name(&error, SD_BUS_ERROR_DISCONNECTED))
1693 return true;
1694
1695 if (sd_bus_error_has_name(&error, SD_BUS_ERROR_UNKNOWN_OBJECT))
1696 return false;
1697
1698 return r;
1699 }
1700
1701 /* We don't actually care about the state really. The fact
1702 * that we could read the job state is enough for us */
1703
1704 return true;
1705 }
1706
1707 int manager_get_machine_by_pid(Manager *m, pid_t pid, Machine **machine) {
1708 Machine *mm;
1709 int r;
1710
1711 assert(m);
1712 assert(pid >= 1);
1713 assert(machine);
1714
1715 mm = hashmap_get(m->machine_leaders, PID_TO_PTR(pid));
1716 if (!mm) {
1717 _cleanup_free_ char *unit = NULL;
1718
1719 r = cg_pid_get_unit(pid, &unit);
1720 if (r >= 0)
1721 mm = hashmap_get(m->machine_units, unit);
1722 }
1723 if (!mm)
1724 return 0;
1725
1726 *machine = mm;
1727 return 1;
1728 }
1729
1730 int manager_add_machine(Manager *m, const char *name, Machine **_machine) {
1731 Machine *machine;
1732
1733 assert(m);
1734 assert(name);
1735
1736 machine = hashmap_get(m->machines, name);
1737 if (!machine) {
1738 machine = machine_new(m, _MACHINE_CLASS_INVALID, name);
1739 if (!machine)
1740 return -ENOMEM;
1741 }
1742
1743 if (_machine)
1744 *_machine = machine;
1745
1746 return 0;
1747 }
Unnamed repository; edit this file 'description' to name the repository.