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