src/machine/machined-dbus.c

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