src/machine/machined-dbus.c

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