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