src/portable/portabled-image-bus.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <fcntl.h>
   4 #include <sys/stat.h>
   5 #include <sys/types.h>
   6 #include <unistd.h>
   7
   8 #include "alloc-util.h"
   9 #include "bus-common-errors.h"
  10 #include "bus-get-properties.h"
  11 #include "bus-label.h"
  12 #include "bus-object.h"
  13 #include "bus-polkit.h"
  14 #include "bus-util.h"
  15 #include "discover-image.h"
  16 #include "fd-util.h"
  17 #include "fileio.h"
  18 #include "io-util.h"
  19 #include "missing_capability.h"
  20 #include "os-util.h"
  21 #include "portable.h"
  22 #include "portabled-bus.h"
  23 #include "portabled-image-bus.h"
  24 #include "portabled-image.h"
  25 #include "portabled.h"
  26 #include "process-util.h"
  27 #include "strv.h"
  28 #include "user-util.h"
  29
  30 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_type, image_type, ImageType);
  31
  32 int bus_image_common_get_os_release(
  33                 Manager *m,
  34                 sd_bus_message *message,
  35                 const char *name_or_path,
  36                 Image *image,
  37                 sd_bus_error *error) {
  38
  39         int r;
  40
  41         assert(name_or_path || image);
  42         assert(message);
  43
  44         if (!m) {
  45                 assert(image);
  46                 m = image->userdata;
  47         }
  48
  49         r = bus_image_acquire(m,
  50                               message,
  51                               name_or_path,
  52                               image,
  53                               BUS_IMAGE_AUTHENTICATE_BY_PATH,
  54                               "org.freedesktop.portable1.inspect-images",
  55                               &image,
  56                               error);
  57         if (r < 0)
  58                 return r;
  59         if (r == 0) /* Will call us back */
  60                 return 1;
  61
  62         if (!image->metadata_valid) {
  63                 r = image_read_metadata(image);
  64                 if (r < 0)
  65                         return sd_bus_error_set_errnof(error, r, "Failed to read image metadata: %m");
  66         }
  67
  68         return bus_reply_pair_array(message, image->os_release);
  69 }
  70
  71 static int bus_image_method_get_os_release(sd_bus_message *message, void *userdata, sd_bus_error *error) {
  72         return bus_image_common_get_os_release(NULL, message, NULL, userdata, error);
  73 }
  74
  75 static int append_fd(sd_bus_message *m, PortableMetadata *d) {
  76         _cleanup_fclose_ FILE *f = NULL;
  77         _cleanup_free_ char *buf = NULL;
  78         size_t n = 0;
  79         int r;
  80
  81         assert(m);
  82
  83         if (d) {
  84                 assert(d->fd >= 0);
  85
  86                 f = take_fdopen(&d->fd, "r");
  87                 if (!f)
  88                         return -errno;
  89
  90                 r = read_full_stream(f, &buf, &n);
  91                 if (r < 0)
  92                         return r;
  93         }
  94
  95         return sd_bus_message_append_array(m, 'y', buf, n);
  96 }
  97
  98 int bus_image_common_get_metadata(
  99                 Manager *m,
 100                 sd_bus_message *message,
 101                 const char *name_or_path,
 102                 Image *image,
 103                 sd_bus_error *error) {
 104
 105         _cleanup_ordered_hashmap_free_ OrderedHashmap *extension_releases = NULL;
 106         _cleanup_(portable_metadata_unrefp) PortableMetadata *os_release = NULL;
 107         _cleanup_strv_free_ char **matches = NULL, **extension_images = NULL;
 108         _cleanup_hashmap_free_ Hashmap *unit_files = NULL;
 109         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 110         _cleanup_free_ PortableMetadata **sorted = NULL;
 111         int r;
 112
 113         assert(name_or_path || image);
 114         assert(message);
 115
 116         if (!m) {
 117                 assert(image);
 118                 m = image->userdata;
 119         }
 120
 121         bool have_exti = sd_bus_message_is_method_call(message, NULL, "GetImageMetadataWithExtensions") ||
 122                          sd_bus_message_is_method_call(message, NULL, "GetMetadataWithExtensions");
 123
 124         if (have_exti) {
 125                 r = sd_bus_message_read_strv(message, &extension_images);
 126                 if (r < 0)
 127                         return r;
 128         }
 129
 130         r = sd_bus_message_read_strv(message, &matches);
 131         if (r < 0)
 132                 return r;
 133
 134         if (have_exti) {
 135                 uint64_t input_flags = 0;
 136
 137                 r = sd_bus_message_read(message, "t", &input_flags);
 138                 if (r < 0)
 139                         return r;
 140
 141                 if ((input_flags & ~_PORTABLE_MASK_PUBLIC) != 0)
 142                         return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_INVALID_ARGS,
 143                                                           "Invalid 'flags' parameter '%" PRIu64 "'",
 144                                                           input_flags);
 145         }
 146
 147         r = bus_image_acquire(m,
 148                               message,
 149                               name_or_path,
 150                               image,
 151                               BUS_IMAGE_AUTHENTICATE_BY_PATH,
 152                               "org.freedesktop.portable1.inspect-images",
 153                               &image,
 154                               error);
 155         if (r < 0)
 156                 return r;
 157         if (r == 0) /* Will call us back */
 158                 return 1;
 159
 160         r = portable_extract(
 161                         image->path,
 162                         matches,
 163                         extension_images,
 164                         &os_release,
 165                         &extension_releases,
 166                         &unit_files,
 167                         NULL,
 168                         error);
 169         if (r < 0)
 170                 return r;
 171
 172         r = portable_metadata_hashmap_to_sorted_array(unit_files, &sorted);
 173         if (r < 0)
 174                 return r;
 175
 176         r = sd_bus_message_new_method_return(message, &reply);
 177         if (r < 0)
 178                 return r;
 179
 180         r = sd_bus_message_append(reply, "s", image->path);
 181         if (r < 0)
 182                 return r;
 183
 184         r = append_fd(reply, os_release);
 185         if (r < 0)
 186                 return r;
 187
 188         /* If it was requested, also send back the extension path and the content
 189          * of each extension-release file. Behind a flag, as it's an incompatible
 190          * change. */
 191         if (have_exti) {
 192                 PortableMetadata *extension_release;
 193
 194                 r = sd_bus_message_open_container(reply, 'a', "{say}");
 195                 if (r < 0)
 196                         return r;
 197
 198                 ORDERED_HASHMAP_FOREACH(extension_release, extension_releases) {
 199
 200                         r = sd_bus_message_open_container(reply, 'e', "say");
 201                         if (r < 0)
 202                                 return r;
 203
 204                         r = sd_bus_message_append(reply, "s", extension_release->image_path);
 205                         if (r < 0)
 206                                 return r;
 207
 208                         r = append_fd(reply, extension_release);
 209                         if (r < 0)
 210                                 return r;
 211
 212                         r = sd_bus_message_close_container(reply);
 213                         if (r < 0)
 214                                 return r;
 215                 }
 216
 217                 r = sd_bus_message_close_container(reply);
 218                 if (r < 0)
 219                         return r;
 220         }
 221
 222         r = sd_bus_message_open_container(reply, 'a', "{say}");
 223         if (r < 0)
 224                 return r;
 225
 226         for (size_t i = 0; i < hashmap_size(unit_files); i++) {
 227
 228                 r = sd_bus_message_open_container(reply, 'e', "say");
 229                 if (r < 0)
 230                         return r;
 231
 232                 r = sd_bus_message_append(reply, "s", sorted[i]->name);
 233                 if (r < 0)
 234                         return r;
 235
 236                 r = append_fd(reply, sorted[i]);
 237                 if (r < 0)
 238                         return r;
 239
 240                 r = sd_bus_message_close_container(reply);
 241                 if (r < 0)
 242                         return r;
 243         }
 244
 245         r = sd_bus_message_close_container(reply);
 246         if (r < 0)
 247                 return r;
 248
 249         return sd_bus_send(NULL, reply, NULL);
 250 }
 251
 252 static int bus_image_method_get_metadata(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 253         return bus_image_common_get_metadata(NULL, message, NULL, userdata, error);
 254 }
 255
 256 static int bus_image_method_get_state(
 257                 sd_bus_message *message,
 258                 void *userdata,
 259                 sd_bus_error *error) {
 260
 261         _cleanup_strv_free_ char **extension_images = NULL;
 262         Image *image = userdata;
 263         PortableState state;
 264         int r;
 265
 266         assert(message);
 267         assert(image);
 268
 269         if (sd_bus_message_is_method_call(message, NULL, "GetStateWithExtensions")) {
 270                 uint64_t input_flags = 0;
 271
 272                 r = sd_bus_message_read_strv(message, &extension_images);
 273                 if (r < 0)
 274                         return r;
 275
 276                 r = sd_bus_message_read(message, "t", &input_flags);
 277                 if (r < 0)
 278                         return r;
 279
 280                 /* No flags are supported by this method for now. */
 281                 if (input_flags != 0)
 282                         return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_INVALID_ARGS,
 283                                                           "Invalid 'flags' parameter '%" PRIu64 "'",
 284                                                           input_flags);
 285         }
 286
 287         r = portable_get_state(
 288                         sd_bus_message_get_bus(message),
 289                         image->path,
 290                         extension_images,
 291                         0,
 292                         &state,
 293                         error);
 294         if (r < 0)
 295                 return r;
 296
 297         return sd_bus_reply_method_return(message, "s", portable_state_to_string(state));
 298 }
 299
 300 int bus_image_common_attach(
 301                 Manager *m,
 302                 sd_bus_message *message,
 303                 const char *name_or_path,
 304                 Image *image,
 305                 sd_bus_error *error) {
 306
 307         _cleanup_strv_free_ char **matches = NULL, **extension_images = NULL;
 308         PortableChange *changes = NULL;
 309         PortableFlags flags = 0;
 310         const char *profile, *copy_mode;
 311         size_t n_changes = 0;
 312         int r;
 313
 314         assert(message);
 315         assert(name_or_path || image);
 316
 317         if (!m) {
 318                 assert(image);
 319                 m = image->userdata;
 320         }
 321
 322         if (sd_bus_message_is_method_call(message, NULL, "AttachImageWithExtensions") ||
 323             sd_bus_message_is_method_call(message, NULL, "AttachWithExtensions")) {
 324                 r = sd_bus_message_read_strv(message, &extension_images);
 325                 if (r < 0)
 326                         return r;
 327         }
 328
 329         r = sd_bus_message_read_strv(message, &matches);
 330         if (r < 0)
 331                 return r;
 332
 333         r = sd_bus_message_read(message, "s", &profile);
 334         if (r < 0)
 335                 return r;
 336
 337         if (sd_bus_message_is_method_call(message, NULL, "AttachImageWithExtensions") ||
 338             sd_bus_message_is_method_call(message, NULL, "AttachWithExtensions")) {
 339                 uint64_t input_flags = 0;
 340
 341                 r = sd_bus_message_read(message, "st", &copy_mode, &input_flags);
 342                 if (r < 0)
 343                         return r;
 344                 if ((input_flags & ~_PORTABLE_MASK_PUBLIC) != 0)
 345                         return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_INVALID_ARGS,
 346                                                           "Invalid 'flags' parameter '%" PRIu64 "'",
 347                                                           input_flags);
 348                 flags |= input_flags;
 349         } else {
 350                 int runtime;
 351
 352                 r = sd_bus_message_read(message, "bs", &runtime, &copy_mode);
 353                 if (r < 0)
 354                         return r;
 355
 356                 if (runtime)
 357                         flags |= PORTABLE_RUNTIME;
 358         }
 359
 360         if (streq(copy_mode, "symlink"))
 361                 flags |= PORTABLE_PREFER_SYMLINK;
 362         else if (streq(copy_mode, "copy"))
 363                 flags |= PORTABLE_PREFER_COPY;
 364         else if (!isempty(copy_mode))
 365                 return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_INVALID_ARGS, "Unknown copy mode '%s'", copy_mode);
 366
 367         r = bus_image_acquire(m,
 368                               message,
 369                               name_or_path,
 370                               image,
 371                               BUS_IMAGE_AUTHENTICATE_ALL,
 372                               "org.freedesktop.portable1.attach-images",
 373                               &image,
 374                               error);
 375         if (r < 0)
 376                 return r;
 377         if (r == 0) /* Will call us back */
 378                 return 1;
 379
 380         r = portable_attach(
 381                         sd_bus_message_get_bus(message),
 382                         image->path,
 383                         matches,
 384                         profile,
 385                         extension_images,
 386                         flags,
 387                         &changes,
 388                         &n_changes,
 389                         error);
 390         if (r < 0)
 391                 goto finish;
 392
 393         r = reply_portable_changes(message, changes, n_changes);
 394
 395 finish:
 396         portable_changes_free(changes, n_changes);
 397         return r;
 398 }
 399
 400 static int bus_image_method_attach(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 401         return bus_image_common_attach(NULL, message, NULL, userdata, error);
 402 }
 403
 404 static int bus_image_method_detach(
 405                 sd_bus_message *message,
 406                 void *userdata,
 407                 sd_bus_error *error) {
 408
 409         _cleanup_strv_free_ char **extension_images = NULL;
 410         PortableChange *changes = NULL;
 411         Image *image = userdata;
 412         Manager *m = image->userdata;
 413         PortableFlags flags = 0;
 414         size_t n_changes = 0;
 415         int r;
 416
 417         assert(message);
 418         assert(image);
 419         assert(m);
 420
 421         if (sd_bus_message_is_method_call(message, NULL, "DetachWithExtensions")) {
 422                 r = sd_bus_message_read_strv(message, &extension_images);
 423                 if (r < 0)
 424                         return r;
 425         }
 426
 427         if (sd_bus_message_is_method_call(message, NULL, "DetachWithExtensions")) {
 428                 uint64_t input_flags = 0;
 429
 430                 r = sd_bus_message_read(message, "t", &input_flags);
 431                 if (r < 0)
 432                         return r;
 433
 434                 if ((input_flags & ~_PORTABLE_MASK_PUBLIC) != 0)
 435                         return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_INVALID_ARGS,
 436                                                           "Invalid 'flags' parameter '%" PRIu64 "'",
 437                                                           input_flags);
 438                 flags |= input_flags;
 439         } else {
 440                 int runtime;
 441
 442                 r = sd_bus_message_read(message, "b", &runtime);
 443                 if (r < 0)
 444                         return r;
 445
 446                 if (runtime)
 447                         flags |= PORTABLE_RUNTIME;
 448         }
 449
 450         r = bus_verify_polkit_async(
 451                         message,
 452                         CAP_SYS_ADMIN,
 453                         "org.freedesktop.portable1.attach-images",
 454                         NULL,
 455                         false,
 456                         UID_INVALID,
 457                         &m->polkit_registry,
 458                         error);
 459         if (r < 0)
 460                 return r;
 461         if (r == 0)
 462                 return 1; /* Will call us back */
 463
 464         r = portable_detach(
 465                         sd_bus_message_get_bus(message),
 466                         image->path,
 467                         extension_images,
 468                         flags,
 469                         &changes,
 470                         &n_changes,
 471                         error);
 472         if (r < 0)
 473                 goto finish;
 474
 475         r = reply_portable_changes(message, changes, n_changes);
 476
 477 finish:
 478         portable_changes_free(changes, n_changes);
 479         return r;
 480 }
 481
 482 int bus_image_common_remove(
 483                 Manager *m,
 484                 sd_bus_message *message,
 485                 const char *name_or_path,
 486                 Image *image,
 487                 sd_bus_error *error) {
 488
 489         _cleanup_close_pair_ int errno_pipe_fd[2] = { -1, -1 };
 490         _cleanup_(sigkill_waitp) pid_t child = 0;
 491         PortableState state;
 492         int r;
 493
 494         assert(message);
 495         assert(name_or_path || image);
 496
 497         if (!m) {
 498                 assert(image);
 499                 m = image->userdata;
 500         }
 501
 502         if (m->n_operations >= OPERATIONS_MAX)
 503                 return sd_bus_error_set(error, SD_BUS_ERROR_LIMITS_EXCEEDED, "Too many ongoing operations.");
 504
 505         r = bus_image_acquire(m,
 506                               message,
 507                               name_or_path,
 508                               image,
 509                               BUS_IMAGE_AUTHENTICATE_ALL,
 510                               "org.freedesktop.portable1.manage-images",
 511                               &image,
 512                               error);
 513         if (r < 0)
 514                 return r;
 515         if (r == 0)
 516                 return 1; /* Will call us back */
 517
 518         r = portable_get_state(
 519                         sd_bus_message_get_bus(message),
 520                         image->path,
 521                         NULL,
 522                         0,
 523                         &state,
 524                         error);
 525         if (r < 0)
 526                 return r;
 527
 528         if (state != PORTABLE_DETACHED)
 529                 return sd_bus_error_set_errnof(error, EBUSY, "Image '%s' is not detached, refusing.", image->path);
 530
 531         if (pipe2(errno_pipe_fd, O_CLOEXEC|O_NONBLOCK) < 0)
 532                 return sd_bus_error_set_errnof(error, errno, "Failed to create pipe: %m");
 533
 534         r = safe_fork("(sd-imgrm)", FORK_RESET_SIGNALS, &child);
 535         if (r < 0)
 536                 return sd_bus_error_set_errnof(error, r, "Failed to fork(): %m");
 537         if (r == 0) {
 538                 errno_pipe_fd[0] = safe_close(errno_pipe_fd[0]);
 539
 540                 r = image_remove(image);
 541                 if (r < 0) {
 542                         (void) write(errno_pipe_fd[1], &r, sizeof(r));
 543                         _exit(EXIT_FAILURE);
 544                 }
 545
 546                 _exit(EXIT_SUCCESS);
 547         }
 548
 549         errno_pipe_fd[1] = safe_close(errno_pipe_fd[1]);
 550
 551         r = operation_new(m, child, message, errno_pipe_fd[0], NULL);
 552         if (r < 0)
 553                 return r;
 554
 555         child = 0;
 556         errno_pipe_fd[0] = -1;
 557
 558         return 1;
 559 }
 560
 561 static int bus_image_method_remove(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 562         return bus_image_common_remove(NULL, message, NULL, userdata, error);
 563 }
 564
 565 /* Given two PortableChange arrays, return a new array that has all elements of the first that are
 566  * not also present in the second, comparing the basename of the path values. */
 567 static int normalize_portable_changes(
 568                 const PortableChange *changes_attached,
 569                 size_t n_changes_attached,
 570                 const PortableChange *changes_detached,
 571                 size_t n_changes_detached,
 572                 PortableChange **ret_changes,
 573                 size_t *ret_n_changes) {
 574
 575         PortableChange *changes = NULL;
 576         size_t n_changes = 0;
 577         int r = 0;
 578
 579         assert(ret_n_changes);
 580         assert(ret_changes);
 581
 582         if (n_changes_detached == 0)
 583                 return 0; /* Nothing to do */
 584
 585         changes = new0(PortableChange, n_changes_attached + n_changes_detached);
 586         if (!changes)
 587                 return -ENOMEM;
 588
 589         /* Corner case: only detached, nothing attached */
 590         if (n_changes_attached == 0) {
 591                 memcpy(changes, changes_detached, sizeof(PortableChange) * n_changes_detached);
 592                 *ret_changes = TAKE_PTR(changes);
 593                 *ret_n_changes = n_changes_detached;
 594
 595                 return 0;
 596         }
 597
 598         for (size_t i = 0; i < n_changes_detached; ++i) {
 599                 bool found = false;
 600
 601                 for (size_t j = 0; j < n_changes_attached; ++j)
 602                         if (streq(basename(changes_detached[i].path), basename(changes_attached[j].path))) {
 603                                 found = true;
 604                                 break;
 605                         }
 606
 607                 if (!found) {
 608                         _cleanup_free_ char *path = NULL, *source = NULL;
 609
 610                         path = strdup(changes_detached[i].path);
 611                         if (!path) {
 612                                 r = -ENOMEM;
 613                                 goto fail;
 614                         }
 615
 616                         if (changes_detached[i].source) {
 617                                 source = strdup(changes_detached[i].source);
 618                                 if (!source) {
 619                                         r = -ENOMEM;
 620                                         goto fail;
 621                                 }
 622                         }
 623
 624                         changes[n_changes++] = (PortableChange) {
 625                                 .type_or_errno = changes_detached[i].type_or_errno,
 626                                 .path = TAKE_PTR(path),
 627                                 .source = TAKE_PTR(source),
 628                         };
 629                 }
 630         }
 631
 632         *ret_n_changes = n_changes;
 633         *ret_changes = TAKE_PTR(changes);
 634
 635         return 0;
 636
 637 fail:
 638         portable_changes_free(changes, n_changes);
 639         return r;
 640 }
 641
 642 int bus_image_common_reattach(
 643                 Manager *m,
 644                 sd_bus_message *message,
 645                 const char *name_or_path,
 646                 Image *image,
 647                 sd_bus_error *error) {
 648
 649         PortableChange *changes_detached = NULL, *changes_attached = NULL, *changes_gone = NULL;
 650         size_t n_changes_detached = 0, n_changes_attached = 0, n_changes_gone = 0;
 651         _cleanup_strv_free_ char **matches = NULL, **extension_images = NULL;
 652         PortableFlags flags = PORTABLE_REATTACH;
 653         const char *profile, *copy_mode;
 654         int r;
 655
 656         assert(message);
 657         assert(name_or_path || image);
 658
 659         if (!m) {
 660                 assert(image);
 661                 m = image->userdata;
 662         }
 663
 664         if (sd_bus_message_is_method_call(message, NULL, "ReattachImageWithExtensions") ||
 665             sd_bus_message_is_method_call(message, NULL, "ReattachWithExtensions")) {
 666                 r = sd_bus_message_read_strv(message, &extension_images);
 667                 if (r < 0)
 668                         return r;
 669         }
 670
 671         r = sd_bus_message_read_strv(message, &matches);
 672         if (r < 0)
 673                 return r;
 674
 675         r = sd_bus_message_read(message, "s", &profile);
 676         if (r < 0)
 677                 return r;
 678
 679         if (sd_bus_message_is_method_call(message, NULL, "ReattachImageWithExtensions") ||
 680             sd_bus_message_is_method_call(message, NULL, "ReattachWithExtensions")) {
 681                 uint64_t input_flags = 0;
 682
 683                 r = sd_bus_message_read(message, "st", &copy_mode, &input_flags);
 684                 if (r < 0)
 685                         return r;
 686
 687                 if ((input_flags & ~_PORTABLE_MASK_PUBLIC) != 0)
 688                         return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_INVALID_ARGS,
 689                                                           "Invalid 'flags' parameter '%" PRIu64 "'",
 690                                                           input_flags);
 691                 flags |= input_flags;
 692         } else {
 693                 int runtime;
 694
 695                 r = sd_bus_message_read(message, "bs", &runtime, &copy_mode);
 696                 if (r < 0)
 697                         return r;
 698
 699                 if (runtime)
 700                         flags |= PORTABLE_RUNTIME;
 701         }
 702
 703         if (streq(copy_mode, "symlink"))
 704                 flags |= PORTABLE_PREFER_SYMLINK;
 705         else if (streq(copy_mode, "copy"))
 706                 flags |= PORTABLE_PREFER_COPY;
 707         else if (!isempty(copy_mode))
 708                 return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_INVALID_ARGS, "Unknown copy mode '%s'", copy_mode);
 709
 710         r = bus_image_acquire(m,
 711                               message,
 712                               name_or_path,
 713                               image,
 714                               BUS_IMAGE_AUTHENTICATE_ALL,
 715                               "org.freedesktop.portable1.attach-images",
 716                               &image,
 717                               error);
 718         if (r < 0)
 719                 return r;
 720         if (r == 0) /* Will call us back */
 721                 return 1;
 722
 723         r = portable_detach(
 724                         sd_bus_message_get_bus(message),
 725                         image->path,
 726                         extension_images,
 727                         flags,
 728                         &changes_detached,
 729                         &n_changes_detached,
 730                         error);
 731         if (r < 0)
 732                 goto finish;
 733
 734         r = portable_attach(
 735                         sd_bus_message_get_bus(message),
 736                         image->path,
 737                         matches,
 738                         profile,
 739                         extension_images,
 740                         flags,
 741                         &changes_attached,
 742                         &n_changes_attached,
 743                         error);
 744         if (r < 0)
 745                 goto finish;
 746
 747         /* We want to return the list of units really removed by the detach,
 748          * and not added again by the attach */
 749         r = normalize_portable_changes(changes_attached, n_changes_attached,
 750                                        changes_detached, n_changes_detached,
 751                                        &changes_gone, &n_changes_gone);
 752         if (r < 0)
 753                 goto finish;
 754
 755         /* First, return the units that are gone (so that the caller can stop them)
 756          * Then, return the units that are changed/added (so that the caller can
 757          * start/restart/enable them) */
 758         r = reply_portable_changes_pair(message,
 759                                         changes_gone, n_changes_gone,
 760                                         changes_attached, n_changes_attached);
 761         if (r < 0)
 762                 goto finish;
 763
 764 finish:
 765         portable_changes_free(changes_detached, n_changes_detached);
 766         portable_changes_free(changes_attached, n_changes_attached);
 767         portable_changes_free(changes_gone, n_changes_gone);
 768         return r;
 769 }
 770
 771 static int bus_image_method_reattach(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 772         return bus_image_common_reattach(NULL, message, NULL, userdata, error);
 773 }
 774
 775 int bus_image_common_mark_read_only(
 776                 Manager *m,
 777                 sd_bus_message *message,
 778                 const char *name_or_path,
 779                 Image *image,
 780                 sd_bus_error *error) {
 781
 782         int r, read_only;
 783
 784         assert(message);
 785         assert(name_or_path || image);
 786
 787         if (!m) {
 788                 assert(image);
 789                 m = image->userdata;
 790         }
 791
 792         r = sd_bus_message_read(message, "b", &read_only);
 793         if (r < 0)
 794                 return r;
 795
 796         r = bus_image_acquire(m,
 797                               message,
 798                               name_or_path,
 799                               image,
 800                               BUS_IMAGE_AUTHENTICATE_ALL,
 801                               "org.freedesktop.portable1.manage-images",
 802                               &image,
 803                               error);
 804         if (r < 0)
 805                 return r;
 806         if (r == 0)
 807                 return 1; /* Will call us back */
 808
 809         r = image_read_only(image, read_only);
 810         if (r < 0)
 811                 return r;
 812
 813         return sd_bus_reply_method_return(message, NULL);
 814 }
 815
 816 static int bus_image_method_mark_read_only(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 817         return bus_image_common_mark_read_only(NULL, message, NULL, userdata, error);
 818 }
 819
 820 int bus_image_common_set_limit(
 821                 Manager *m,
 822                 sd_bus_message *message,
 823                 const char *name_or_path,
 824                 Image *image,
 825                 sd_bus_error *error) {
 826
 827         uint64_t limit;
 828         int r;
 829
 830         assert(message);
 831         assert(name_or_path || image);
 832
 833         if (!m) {
 834                 assert(image);
 835                 m = image->userdata;
 836         }
 837
 838         r = sd_bus_message_read(message, "t", &limit);
 839         if (r < 0)
 840                 return r;
 841         if (!FILE_SIZE_VALID_OR_INFINITY(limit))
 842                 return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "New limit out of range");
 843
 844         r = bus_image_acquire(m,
 845                               message,
 846                               name_or_path,
 847                               image,
 848                               BUS_IMAGE_AUTHENTICATE_ALL,
 849                               "org.freedesktop.portable1.manage-images",
 850                               &image,
 851                               error);
 852         if (r < 0)
 853                 return r;
 854         if (r == 0)
 855                 return 1; /* Will call us back */
 856
 857         r = image_set_limit(image, limit);
 858         if (r < 0)
 859                 return r;
 860
 861         return sd_bus_reply_method_return(message, NULL);
 862 }
 863
 864 static int bus_image_method_set_limit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 865         return bus_image_common_set_limit(NULL, message, NULL, userdata, error);
 866 }
 867
 868 const sd_bus_vtable image_vtable[] = {
 869         SD_BUS_VTABLE_START(0),
 870         SD_BUS_PROPERTY("Name", "s", NULL, offsetof(Image, name), 0),
 871         SD_BUS_PROPERTY("Path", "s", NULL, offsetof(Image, path), 0),
 872         SD_BUS_PROPERTY("Type", "s", property_get_type,  offsetof(Image, type), 0),
 873         SD_BUS_PROPERTY("ReadOnly", "b", bus_property_get_bool, offsetof(Image, read_only), 0),
 874         SD_BUS_PROPERTY("CreationTimestamp", "t", NULL, offsetof(Image, crtime), 0),
 875         SD_BUS_PROPERTY("ModificationTimestamp", "t", NULL, offsetof(Image, mtime), 0),
 876         SD_BUS_PROPERTY("Usage", "t", NULL, offsetof(Image, usage), 0),
 877         SD_BUS_PROPERTY("Limit", "t", NULL, offsetof(Image, limit), 0),
 878         SD_BUS_PROPERTY("UsageExclusive", "t", NULL, offsetof(Image, usage_exclusive), 0),
 879         SD_BUS_PROPERTY("LimitExclusive", "t", NULL, offsetof(Image, limit_exclusive), 0),
 880         SD_BUS_METHOD_WITH_ARGS("GetOSRelease",
 881                                 SD_BUS_NO_ARGS,
 882                                 SD_BUS_RESULT("a{ss}", os_release),
 883                                 bus_image_method_get_os_release,
 884                                 SD_BUS_VTABLE_UNPRIVILEGED),
 885         SD_BUS_METHOD_WITH_ARGS("GetMetadata",
 886                                 SD_BUS_ARGS("as", matches),
 887                                 SD_BUS_RESULT("s", image,
 888                                               "ay", os_release,
 889                                               "a{say}", units),
 890                                 bus_image_method_get_metadata,
 891                                 SD_BUS_VTABLE_UNPRIVILEGED),
 892         SD_BUS_METHOD_WITH_ARGS("GetMetadataWithExtensions",
 893                                 SD_BUS_ARGS("as", extensions,
 894                                             "as", matches,
 895                                             "t", flags),
 896                                 SD_BUS_RESULT("s", image,
 897                                               "ay", os_release,
 898                                               "a{say}", extensions,
 899                                               "a{say}", units),
 900                                 bus_image_method_get_metadata,
 901                                 SD_BUS_VTABLE_UNPRIVILEGED),
 902         SD_BUS_METHOD_WITH_ARGS("GetState",
 903                                 SD_BUS_NO_ARGS,
 904                                 SD_BUS_RESULT("s", state),
 905                                 bus_image_method_get_state,
 906                                 SD_BUS_VTABLE_UNPRIVILEGED),
 907         SD_BUS_METHOD_WITH_ARGS("GetStateWithExtensions",
 908                                 SD_BUS_ARGS("as", extensions,
 909                                             "t", flags),
 910                                 SD_BUS_RESULT("s", state),
 911                                 bus_image_method_get_state,
 912                                 SD_BUS_VTABLE_UNPRIVILEGED),
 913         SD_BUS_METHOD_WITH_ARGS("Attach",
 914                                 SD_BUS_ARGS("as", matches,
 915                                             "s", profile,
 916                                             "b", runtime,
 917                                             "s", copy_mode),
 918                                 SD_BUS_RESULT("a(sss)", changes),
 919                                 bus_image_method_attach,
 920                                 SD_BUS_VTABLE_UNPRIVILEGED),
 921         SD_BUS_METHOD_WITH_ARGS("AttachWithExtensions",
 922                                 SD_BUS_ARGS("as", extensions,
 923                                             "as", matches,
 924                                             "s", profile,
 925                                             "s", copy_mode,
 926                                             "t", flags),
 927                                 SD_BUS_RESULT("a(sss)", changes),
 928                                 bus_image_method_attach,
 929                                 SD_BUS_VTABLE_UNPRIVILEGED),
 930         SD_BUS_METHOD_WITH_ARGS("Detach",
 931                                 SD_BUS_ARGS("b", runtime),
 932                                 SD_BUS_RESULT("a(sss)", changes),
 933                                 bus_image_method_detach,
 934                                 SD_BUS_VTABLE_UNPRIVILEGED),
 935         SD_BUS_METHOD_WITH_ARGS("DetachWithExtensions",
 936                                 SD_BUS_ARGS("as", extensions,
 937                                             "t", flags),
 938                                 SD_BUS_RESULT("a(sss)", changes),
 939                                 bus_image_method_detach,
 940                                 SD_BUS_VTABLE_UNPRIVILEGED),
 941         SD_BUS_METHOD_WITH_ARGS("Reattach",
 942                                 SD_BUS_ARGS("as", matches,
 943                                             "s", profile,
 944                                             "b", runtime,
 945                                             "s", copy_mode),
 946                                 SD_BUS_RESULT("a(sss)", changes_removed,
 947                                               "a(sss)", changes_updated),
 948                                 bus_image_method_reattach,
 949                                 SD_BUS_VTABLE_UNPRIVILEGED),
 950         SD_BUS_METHOD_WITH_ARGS("ReattacheWithExtensions",
 951                                 SD_BUS_ARGS("as", extensions,
 952                                             "as", matches,
 953                                             "s", profile,
 954                                             "s", copy_mode,
 955                                             "t", flags),
 956                                 SD_BUS_RESULT("a(sss)", changes_removed,
 957                                               "a(sss)", changes_updated),
 958                                 bus_image_method_reattach,
 959                                 SD_BUS_VTABLE_UNPRIVILEGED),
 960         SD_BUS_METHOD_WITH_ARGS("Remove",
 961                                 SD_BUS_NO_ARGS,
 962                                 SD_BUS_NO_RESULT,
 963                                 bus_image_method_remove,
 964                                 SD_BUS_VTABLE_UNPRIVILEGED),
 965         SD_BUS_METHOD_WITH_ARGS("MarkReadOnly",
 966                                 SD_BUS_ARGS("b", read_only),
 967                                 SD_BUS_NO_RESULT,
 968                                 bus_image_method_mark_read_only,
 969                                 SD_BUS_VTABLE_UNPRIVILEGED),
 970         SD_BUS_METHOD_WITH_ARGS("SetLimit",
 971                                 SD_BUS_ARGS("t", limit),
 972                                 SD_BUS_NO_RESULT,
 973                                 bus_image_method_set_limit,
 974                                 SD_BUS_VTABLE_UNPRIVILEGED),
 975         SD_BUS_VTABLE_END
 976 };
 977
 978 int bus_image_path(Image *image, char **ret) {
 979         assert(image);
 980         assert(ret);
 981
 982         if (!image->discoverable)
 983                 return -EINVAL;
 984
 985         return sd_bus_path_encode("/org/freedesktop/portable1/image", image->name, ret);
 986 }
 987
 988 int bus_image_acquire(
 989                 Manager *m,
 990                 sd_bus_message *message,
 991                 const char *name_or_path,
 992                 Image *image,
 993                 ImageAcquireMode mode,
 994                 const char *polkit_action,
 995                 Image **ret,
 996                 sd_bus_error *error) {
 997
 998         _cleanup_(image_unrefp) Image *loaded = NULL;
 999         Image *cached;
1000         int r;
1001
1002         assert(m);
1003         assert(message);
1004         assert(name_or_path || image);
1005         assert(mode >= 0);
1006         assert(mode < _BUS_IMAGE_ACQUIRE_MODE_MAX);
1007         assert(polkit_action || mode == BUS_IMAGE_REFUSE_BY_PATH);
1008         assert(ret);
1009
1010         /* Acquires an 'Image' object if not acquired yet, and enforces necessary authentication while doing so. */
1011
1012         if (mode == BUS_IMAGE_AUTHENTICATE_ALL) {
1013                 r = bus_verify_polkit_async(
1014                                 message,
1015                                 CAP_SYS_ADMIN,
1016                                 polkit_action,
1017                                 NULL,
1018                                 false,
1019                                 UID_INVALID,
1020                                 &m->polkit_registry,
1021                                 error);
1022                 if (r < 0)
1023                         return r;
1024                 if (r == 0) { /* Will call us back */
1025                         *ret = NULL;
1026                         return 0;
1027                 }
1028         }
1029
1030         /* Already passed in? */
1031         if (image) {
1032                 *ret = image;
1033                 return 1;
1034         }
1035
1036         /* Let's see if this image is already cached? */
1037         cached = manager_image_cache_get(m, name_or_path);
1038         if (cached) {
1039                 *ret = cached;
1040                 return 1;
1041         }
1042
1043         if (image_name_is_valid(name_or_path)) {
1044
1045                 /* If it's a short name, let's search for it */
1046                 r = image_find(IMAGE_PORTABLE, name_or_path, NULL, &loaded);
1047                 if (r == -ENOENT)
1048                         return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PORTABLE_IMAGE, "No image '%s' found.", name_or_path);
1049
1050                 /* other errors are handled below… */
1051         } else {
1052                 /* Don't accept path if this is always forbidden */
1053                 if (mode == BUS_IMAGE_REFUSE_BY_PATH)
1054                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Expected image name, not path in place of '%s'.", name_or_path);
1055
1056                 if (!path_is_absolute(name_or_path))
1057                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Image name '%s' is not valid or not a valid path.", name_or_path);
1058
1059                 if (!path_is_normalized(name_or_path))
1060                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Image path '%s' is not normalized.", name_or_path);
1061
1062                 if (mode == BUS_IMAGE_AUTHENTICATE_BY_PATH) {
1063                         r = bus_verify_polkit_async(
1064                                         message,
1065                                         CAP_SYS_ADMIN,
1066                                         polkit_action,
1067                                         NULL,
1068                                         false,
1069                                         UID_INVALID,
1070                                         &m->polkit_registry,
1071                                         error);
1072                         if (r < 0)
1073                                 return r;
1074                         if (r == 0) { /* Will call us back */
1075                                 *ret = NULL;
1076                                 return 0;
1077                         }
1078                 }
1079
1080                 r = image_from_path(name_or_path, &loaded);
1081         }
1082         if (r == -EMEDIUMTYPE) {
1083                 sd_bus_error_setf(error, BUS_ERROR_BAD_PORTABLE_IMAGE_TYPE, "Typ of image '%s' not recognized; supported image types are directories/btrfs subvolumes, block devices, and raw disk image files with suffix '.raw'.", name_or_path);
1084                 return r;
1085         }
1086         if (r < 0)
1087                 return r;
1088
1089         /* Add what we just loaded to the cache. This has as side-effect that the object stays in memory until the
1090          * cache is purged again, i.e. at least for the current event loop iteration, which is all we need, and which
1091          * means we don't actually need to ref the return object. */
1092         r = manager_image_cache_add(m, loaded);
1093         if (r < 0)
1094                 return r;
1095
1096         *ret = loaded;
1097         return 1;
1098 }
1099
1100 int bus_image_object_find(
1101                 sd_bus *bus,
1102                 const char *path,
1103                 const char *interface,
1104                 void *userdata,
1105                 void **found,
1106                 sd_bus_error *error) {
1107
1108         _cleanup_free_ char *e = NULL;
1109         Manager *m = userdata;
1110         Image *image = NULL;
1111         int r;
1112
1113         assert(bus);
1114         assert(path);
1115         assert(interface);
1116         assert(found);
1117
1118         r = sd_bus_path_decode(path, "/org/freedesktop/portable1/image", &e);
1119         if (r < 0)
1120                 return 0;
1121         if (r == 0)
1122                 goto not_found;
1123
1124         r = bus_image_acquire(m, sd_bus_get_current_message(bus), e, NULL, BUS_IMAGE_REFUSE_BY_PATH, NULL, &image, error);
1125         if (r == -ENOENT)
1126                 goto not_found;
1127         if (r < 0)
1128                 return r;
1129
1130         *found = image;
1131         return 1;
1132
1133 not_found:
1134         *found = NULL;
1135         return 0;
1136 }
1137
1138 int bus_image_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
1139         _cleanup_hashmap_free_ Hashmap *images = NULL;
1140         _cleanup_strv_free_ char **l = NULL;
1141         Manager *m = userdata;
1142         size_t n = 0;
1143         Image *image;
1144         int r;
1145
1146         assert(bus);
1147         assert(path);
1148         assert(nodes);
1149
1150         images = hashmap_new(&image_hash_ops);
1151         if (!images)
1152                 return -ENOMEM;
1153
1154         r = manager_image_cache_discover(m, images, error);
1155         if (r < 0)
1156                 return r;
1157
1158         HASHMAP_FOREACH(image, images) {
1159                 char *p;
1160
1161                 r = bus_image_path(image, &p);
1162                 if (r < 0)
1163                         return r;
1164
1165                 if (!GREEDY_REALLOC(l, n+2)) {
1166                         free(p);
1167                         return -ENOMEM;
1168                 }
1169
1170                 l[n++] = p;
1171                 l[n] = NULL;
1172         }
1173
1174         *nodes = TAKE_PTR(l);
1175
1176         return 1;
1177 }
1178
1179 const BusObjectImplementation image_object = {
1180         "/org/freedesktop/portable1/image",
1181         "org.freedesktop.portable1.Image",
1182         .fallback_vtables = BUS_FALLBACK_VTABLES({image_vtable, bus_image_object_find}),
1183         .node_enumerator = bus_image_node_enumerator,
1184 };