src/portable/portable.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include "bus-common-errors.h"
   4 #include "bus-error.h"
   5 #include "conf-files.h"
   6 #include "copy.h"
   7 #include "def.h"
   8 #include "dirent-util.h"
   9 #include "dissect-image.h"
  10 #include "fd-util.h"
  11 #include "fileio.h"
  12 #include "fs-util.h"
  13 #include "io-util.h"
  14 #include "locale-util.h"
  15 #include "loop-util.h"
  16 #include "machine-image.h"
  17 #include "mkdir.h"
  18 #include "nulstr-util.h"
  19 #include "os-util.h"
  20 #include "path-lookup.h"
  21 #include "portable.h"
  22 #include "process-util.h"
  23 #include "set.h"
  24 #include "signal-util.h"
  25 #include "socket-util.h"
  26 #include "sort-util.h"
  27 #include "string-table.h"
  28 #include "strv.h"
  29 #include "tmpfile-util.h"
  30 #include "user-util.h"
  31
  32 static const char profile_dirs[] = CONF_PATHS_NULSTR("systemd/portable/profile");
  33
  34 /* Markers used in the first line of our 20-portable.conf unit file drop-in to determine, that a) the unit file was
  35  * dropped there by the portable service logic and b) for which image it was dropped there. */
  36 #define PORTABLE_DROPIN_MARKER_BEGIN "# Drop-in created for image '"
  37 #define PORTABLE_DROPIN_MARKER_END "', do not edit."
  38
  39 static bool prefix_match(const char *unit, const char *prefix) {
  40         const char *p;
  41
  42         p = startswith(unit, prefix);
  43         if (!p)
  44                 return false;
  45
  46         /* Only respect prefixes followed by dash or dot or when there's a complete match */
  47         return IN_SET(*p, '-', '.', '@', 0);
  48 }
  49
  50 static bool unit_match(const char *unit, char **matches) {
  51         const char *dot;
  52         char **i;
  53
  54         dot = strrchr(unit, '.');
  55         if (!dot)
  56                 return false;
  57
  58         if (!STR_IN_SET(dot, ".service", ".socket", ".target", ".timer", ".path"))
  59                 return false;
  60
  61         /* Empty match expression means: everything */
  62         if (strv_isempty(matches))
  63                 return true;
  64
  65         /* Otherwise, at least one needs to match */
  66         STRV_FOREACH(i, matches)
  67                 if (prefix_match(unit, *i))
  68                         return true;
  69
  70         return false;
  71 }
  72
  73 static PortableMetadata *portable_metadata_new(const char *name, int fd) {
  74         PortableMetadata *m;
  75
  76         m = malloc0(offsetof(PortableMetadata, name) + strlen(name) + 1);
  77         if (!m)
  78                 return NULL;
  79
  80         strcpy(m->name, name);
  81         m->fd = fd;
  82
  83         return m;
  84 }
  85
  86 PortableMetadata *portable_metadata_unref(PortableMetadata *i) {
  87         if (!i)
  88                 return NULL;
  89
  90         safe_close(i->fd);
  91         free(i->source);
  92
  93         return mfree(i);
  94 }
  95
  96 static int compare_metadata(PortableMetadata *const *x, PortableMetadata *const *y) {
  97         return strcmp((*x)->name, (*y)->name);
  98 }
  99
 100 int portable_metadata_hashmap_to_sorted_array(Hashmap *unit_files, PortableMetadata ***ret) {
 101
 102         _cleanup_free_ PortableMetadata **sorted = NULL;
 103         Iterator iterator;
 104         PortableMetadata *item;
 105         size_t k = 0;
 106
 107         sorted = new(PortableMetadata*, hashmap_size(unit_files));
 108         if (!sorted)
 109                 return -ENOMEM;
 110
 111         HASHMAP_FOREACH(item, unit_files, iterator)
 112                 sorted[k++] = item;
 113
 114         assert(k == hashmap_size(unit_files));
 115
 116         typesafe_qsort(sorted, k, compare_metadata);
 117
 118         *ret = TAKE_PTR(sorted);
 119         return 0;
 120 }
 121
 122 static int send_item(
 123                 int socket_fd,
 124                 const char *name,
 125                 int fd) {
 126
 127         union {
 128                 struct cmsghdr cmsghdr;
 129                 uint8_t buf[CMSG_SPACE(sizeof(int))];
 130         } control = {};
 131         struct iovec iovec;
 132         struct msghdr mh = {
 133                 .msg_control = &control,
 134                 .msg_controllen = sizeof(control),
 135                 .msg_iov = &iovec,
 136                 .msg_iovlen = 1,
 137         };
 138         struct cmsghdr *cmsg;
 139         _cleanup_close_ int data_fd = -1;
 140
 141         assert(socket_fd >= 0);
 142         assert(name);
 143         assert(fd >= 0);
 144
 145         data_fd = fd_duplicate_data_fd(fd);
 146         if (data_fd < 0)
 147                 return data_fd;
 148
 149         cmsg = CMSG_FIRSTHDR(&mh);
 150         cmsg->cmsg_level = SOL_SOCKET;
 151         cmsg->cmsg_type = SCM_RIGHTS;
 152         cmsg->cmsg_len = CMSG_LEN(sizeof(int));
 153         memcpy(CMSG_DATA(cmsg), &data_fd, sizeof(int));
 154
 155         mh.msg_controllen = CMSG_SPACE(sizeof(int));
 156         iovec = IOVEC_MAKE_STRING(name);
 157
 158         if (sendmsg(socket_fd, &mh, MSG_NOSIGNAL) < 0)
 159                 return -errno;
 160
 161         return 0;
 162 }
 163
 164 static int recv_item(
 165                 int socket_fd,
 166                 char **ret_name,
 167                 int *ret_fd) {
 168
 169         union {
 170                 struct cmsghdr cmsghdr;
 171                 uint8_t buf[CMSG_SPACE(sizeof(int))];
 172         } control = {};
 173         char buffer[PATH_MAX+2];
 174         struct iovec iov = IOVEC_INIT(buffer, sizeof(buffer)-1);
 175         struct msghdr mh = {
 176                 .msg_control = &control,
 177                 .msg_controllen = sizeof(control),
 178                 .msg_iov = &iov,
 179                 .msg_iovlen = 1,
 180         };
 181         struct cmsghdr *cmsg;
 182         _cleanup_close_ int found_fd = -1;
 183         char *copy;
 184         ssize_t n;
 185
 186         assert(socket_fd >= 0);
 187         assert(ret_name);
 188         assert(ret_fd);
 189
 190         n = recvmsg(socket_fd, &mh, MSG_CMSG_CLOEXEC);
 191         if (n < 0)
 192                 return -errno;
 193
 194         CMSG_FOREACH(cmsg, &mh) {
 195                 if (cmsg->cmsg_level == SOL_SOCKET &&
 196                     cmsg->cmsg_type == SCM_RIGHTS) {
 197
 198                         if (cmsg->cmsg_len == CMSG_LEN(sizeof(int))) {
 199                                 assert(found_fd < 0);
 200                                 found_fd = *(int*) CMSG_DATA(cmsg);
 201                                 break;
 202                         }
 203
 204                         cmsg_close_all(&mh);
 205                         return -EIO;
 206                 }
 207         }
 208
 209         buffer[n] = 0;
 210
 211         copy = strdup(buffer);
 212         if (!copy)
 213                 return -ENOMEM;
 214
 215         *ret_name = copy;
 216         *ret_fd = TAKE_FD(found_fd);
 217
 218         return 0;
 219 }
 220
 221 DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(portable_metadata_hash_ops, char, string_hash_func, string_compare_func,
 222                                               PortableMetadata, portable_metadata_unref);
 223
 224 static int extract_now(
 225                 const char *where,
 226                 char **matches,
 227                 int socket_fd,
 228                 PortableMetadata **ret_os_release,
 229                 Hashmap **ret_unit_files) {
 230
 231         _cleanup_hashmap_free_ Hashmap *unit_files = NULL;
 232         _cleanup_(portable_metadata_unrefp) PortableMetadata *os_release = NULL;
 233         _cleanup_(lookup_paths_free) LookupPaths paths = {};
 234         _cleanup_close_ int os_release_fd = -1;
 235         _cleanup_free_ char *os_release_path = NULL;
 236         char **i;
 237         int r;
 238
 239         /* Extracts the metadata from a directory tree 'where'. Extracts two kinds of information: the /etc/os-release
 240          * data, and all unit files matching the specified expression. Note that this function is called in two very
 241          * different but also similar contexts. When the tool gets invoked on a directory tree, we'll process it
 242          * directly, and in-process, and thus can return the requested data directly, via 'ret_os_release' and
 243          * 'ret_unit_files'. However, if the tool is invoked on a raw disk image — which needs to be mounted first — we
 244          * are invoked in a child process with private mounts and then need to send the collected data to our
 245          * parent. To handle both cases in one call this function also gets a 'socket_fd' parameter, which when >= 0 is
 246          * used to send the data to the parent. */
 247
 248         assert(where);
 249
 250         /* First, find /etc/os-release and send it upstream (or just save it). */
 251         r = open_os_release(where, &os_release_path, &os_release_fd);
 252         if (r < 0)
 253                 log_debug_errno(r, "Couldn't acquire os-release file, ignoring: %m");
 254         else {
 255                 if (socket_fd >= 0) {
 256                         r = send_item(socket_fd, "/etc/os-release", os_release_fd);
 257                         if (r < 0)
 258                                 return log_debug_errno(r, "Failed to send os-release file: %m");
 259                 }
 260
 261                 if (ret_os_release) {
 262                         os_release = portable_metadata_new("/etc/os-release", os_release_fd);
 263                         if (!os_release)
 264                                 return -ENOMEM;
 265
 266                         os_release_fd = -1;
 267                         os_release->source = TAKE_PTR(os_release_path);
 268                 }
 269         }
 270
 271         /* Then, send unit file data to the parent (or/and add it to the hashmap). For that we use our usual unit
 272          * discovery logic. Note that we force looking inside of /lib/systemd/system/ for units too, as we mightbe
 273          * compiled for a split-usr system but the image might be a legacy-usr one. */
 274         r = lookup_paths_init(&paths, UNIT_FILE_SYSTEM, LOOKUP_PATHS_SPLIT_USR, where);
 275         if (r < 0)
 276                 return log_debug_errno(r, "Failed to acquire lookup paths: %m");
 277
 278         unit_files = hashmap_new(&portable_metadata_hash_ops);
 279         if (!unit_files)
 280                 return -ENOMEM;
 281
 282         STRV_FOREACH(i, paths.search_path) {
 283                 _cleanup_free_ char *resolved = NULL;
 284                 _cleanup_closedir_ DIR *d = NULL;
 285                 struct dirent *de;
 286
 287                 r = chase_symlinks_and_opendir(*i, where, 0, &resolved, &d);
 288                 if (r < 0) {
 289                         log_debug_errno(r, "Failed to open unit path '%s', ignoring: %m", *i);
 290                         continue;
 291                 }
 292
 293                 FOREACH_DIRENT(de, d, return log_debug_errno(errno, "Failed to read directory: %m")) {
 294                         _cleanup_(portable_metadata_unrefp) PortableMetadata *m = NULL;
 295                         _cleanup_close_ int fd = -1;
 296
 297                         if (!unit_name_is_valid(de->d_name, UNIT_NAME_ANY))
 298                                 continue;
 299
 300                         if (!unit_match(de->d_name, matches))
 301                                 continue;
 302
 303                         /* Filter out duplicates */
 304                         if (hashmap_get(unit_files, de->d_name))
 305                                 continue;
 306
 307                         dirent_ensure_type(d, de);
 308                         if (!IN_SET(de->d_type, DT_LNK, DT_REG))
 309                                 continue;
 310
 311                         fd = openat(dirfd(d), de->d_name, O_CLOEXEC|O_RDONLY);
 312                         if (fd < 0) {
 313                                 log_debug_errno(errno, "Failed to open unit file '%s', ignoring: %m", de->d_name);
 314                                 continue;
 315                         }
 316
 317                         if (socket_fd >= 0) {
 318                                 r = send_item(socket_fd, de->d_name, fd);
 319                                 if (r < 0)
 320                                         return log_debug_errno(r, "Failed to send unit metadata to parent: %m");
 321                         }
 322
 323                         m = portable_metadata_new(de->d_name, fd);
 324                         if (!m)
 325                                 return -ENOMEM;
 326                         fd = -1;
 327
 328                         m->source = strjoin(resolved, "/", de->d_name);
 329                         if (!m->source)
 330                                 return -ENOMEM;
 331
 332                         r = hashmap_put(unit_files, m->name, m);
 333                         if (r < 0)
 334                                 return log_debug_errno(r, "Failed to add unit to hashmap: %m");
 335                         m = NULL;
 336                 }
 337         }
 338
 339         if (ret_os_release)
 340                 *ret_os_release = TAKE_PTR(os_release);
 341         if (ret_unit_files)
 342                 *ret_unit_files = TAKE_PTR(unit_files);
 343
 344         return 0;
 345 }
 346
 347 static int portable_extract_by_path(
 348                 const char *path,
 349                 char **matches,
 350                 PortableMetadata **ret_os_release,
 351                 Hashmap **ret_unit_files,
 352                 sd_bus_error *error) {
 353
 354         _cleanup_hashmap_free_ Hashmap *unit_files = NULL;
 355         _cleanup_(portable_metadata_unrefp) PortableMetadata* os_release = NULL;
 356         _cleanup_(loop_device_unrefp) LoopDevice *d = NULL;
 357         int r;
 358
 359         assert(path);
 360
 361         r = loop_device_make_by_path(path, O_RDONLY, &d);
 362         if (r == -EISDIR) {
 363                 /* We can't turn this into a loop-back block device, and this returns EISDIR? Then this is a directory
 364                  * tree and not a raw device. It's easy then. */
 365
 366                 r = extract_now(path, matches, -1, &os_release, &unit_files);
 367                 if (r < 0)
 368                         return r;
 369
 370         } else if (r < 0)
 371                 return log_debug_errno(r, "Failed to set up loopback device: %m");
 372         else {
 373                 _cleanup_(dissected_image_unrefp) DissectedImage *m = NULL;
 374                 _cleanup_(rmdir_and_freep) char *tmpdir = NULL;
 375                 _cleanup_(close_pairp) int seq[2] = { -1, -1 };
 376                 _cleanup_(sigkill_waitp) pid_t child = 0;
 377
 378                 /* We now have a loopback block device, let's fork off a child in its own mount namespace, mount it
 379                  * there, and extract the metadata we need. The metadata is sent from the child back to us. */
 380
 381                 BLOCK_SIGNALS(SIGCHLD);
 382
 383                 r = mkdtemp_malloc("/tmp/inspect-XXXXXX", &tmpdir);
 384                 if (r < 0)
 385                         return log_debug_errno(r, "Failed to create temporary directory: %m");
 386
 387                 r = dissect_image(d->fd, NULL, 0, DISSECT_IMAGE_READ_ONLY|DISSECT_IMAGE_REQUIRE_ROOT|DISSECT_IMAGE_DISCARD_ON_LOOP, &m);
 388                 if (r == -ENOPKG)
 389                         sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Couldn't identify a suitable partition table or file system in '%s'.", path);
 390                 else if (r == -EADDRNOTAVAIL)
 391                         sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "No root partition for specified root hash found in '%s'.", path);
 392                 else if (r == -ENOTUNIQ)
 393                         sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Multiple suitable root partitions found in image '%s'.", path);
 394                 else if (r == -ENXIO)
 395                         sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "No suitable root partition found in image '%s'.", path);
 396                 else if (r == -EPROTONOSUPPORT)
 397                         sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Device '%s' is loopback block device with partition scanning turned off, please turn it on.", path);
 398                 if (r < 0)
 399                         return r;
 400
 401                 if (socketpair(AF_UNIX, SOCK_SEQPACKET|SOCK_CLOEXEC, 0, seq) < 0)
 402                         return log_debug_errno(errno, "Failed to allocated SOCK_SEQPACKET socket: %m");
 403
 404                 r = safe_fork("(sd-dissect)", FORK_RESET_SIGNALS|FORK_DEATHSIG|FORK_NEW_MOUNTNS|FORK_MOUNTNS_SLAVE|FORK_LOG, &child);
 405                 if (r < 0)
 406                         return r;
 407                 if (r == 0) {
 408                         seq[0] = safe_close(seq[0]);
 409
 410                         r = dissected_image_mount(m, tmpdir, UID_INVALID, DISSECT_IMAGE_READ_ONLY|DISSECT_IMAGE_VALIDATE_OS);
 411                         if (r < 0) {
 412                                 log_debug_errno(r, "Failed to mount dissected image: %m");
 413                                 goto child_finish;
 414                         }
 415
 416                         r = extract_now(tmpdir, matches, seq[1], NULL, NULL);
 417
 418                 child_finish:
 419                         _exit(r < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
 420                 }
 421
 422                 seq[1] = safe_close(seq[1]);
 423
 424                 unit_files = hashmap_new(&portable_metadata_hash_ops);
 425                 if (!unit_files)
 426                         return -ENOMEM;
 427
 428                 for (;;) {
 429                         _cleanup_(portable_metadata_unrefp) PortableMetadata *add = NULL;
 430                         _cleanup_free_ char *name = NULL;
 431                         _cleanup_close_ int fd = -1;
 432
 433                         r = recv_item(seq[0], &name, &fd);
 434                         if (r < 0)
 435                                 return log_debug_errno(r, "Failed to receive item: %m");
 436
 437                         /* We can't really distuingish a zero-length datagram without any fds from EOF (both are signalled the
 438                          * same way by recvmsg()). Hence, accept either as end notification. */
 439                         if (isempty(name) && fd < 0)
 440                                 break;
 441
 442                         if (isempty(name) || fd < 0) {
 443                                 log_debug("Invalid item sent from child.");
 444                                 return -EINVAL;
 445                         }
 446
 447                         add = portable_metadata_new(name, fd);
 448                         if (!add)
 449                                 return -ENOMEM;
 450                         fd = -1;
 451
 452                         /* Note that we do not initialize 'add->source' here, as the source path is not usable here as
 453                          * it refers to a path only valid in the short-living namespaced child process we forked
 454                          * here. */
 455
 456                         if (PORTABLE_METADATA_IS_UNIT(add)) {
 457                                 r = hashmap_put(unit_files, add->name, add);
 458                                 if (r < 0)
 459                                         return log_debug_errno(r, "Failed to add item to unit file list: %m");
 460
 461                                 add = NULL;
 462
 463                         } else if (PORTABLE_METADATA_IS_OS_RELEASE(add)) {
 464
 465                                 assert(!os_release);
 466                                 os_release = TAKE_PTR(add);
 467                         } else
 468                                 assert_not_reached("Unexpected metadata item from child.");
 469                 }
 470
 471                 r = wait_for_terminate_and_check("(sd-dissect)", child, 0);
 472                 if (r < 0)
 473                         return r;
 474                 child = 0;
 475         }
 476
 477         if (!os_release)
 478                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Image '%s' lacks os-release data, refusing.", path);
 479
 480         if (hashmap_isempty(unit_files))
 481                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Couldn't find any matching unit files in image '%s', refusing.", path);
 482
 483         if (ret_unit_files)
 484                 *ret_unit_files = TAKE_PTR(unit_files);
 485
 486         if (ret_os_release)
 487                 *ret_os_release = TAKE_PTR(os_release);
 488
 489         return 0;
 490 }
 491
 492 int portable_extract(
 493                 const char *name_or_path,
 494                 char **matches,
 495                 PortableMetadata **ret_os_release,
 496                 Hashmap **ret_unit_files,
 497                 sd_bus_error *error) {
 498
 499         _cleanup_(image_unrefp) Image *image = NULL;
 500         int r;
 501
 502         assert(name_or_path);
 503
 504         r = image_find_harder(IMAGE_PORTABLE, name_or_path, &image);
 505         if (r < 0)
 506                 return r;
 507
 508         return portable_extract_by_path(image->path, matches, ret_os_release, ret_unit_files, error);
 509 }
 510
 511 static int unit_file_is_active(
 512                 sd_bus *bus,
 513                 const char *name,
 514                 sd_bus_error *error) {
 515
 516         static const char *const active_states[] = {
 517                 "activating",
 518                 "active",
 519                 "reloading",
 520                 "deactivating",
 521                 NULL,
 522         };
 523         int r;
 524
 525         if (!bus)
 526                 return false;
 527
 528         /* If we are looking at a plain or instance things are easy, we can just query the state */
 529         if (unit_name_is_valid(name, UNIT_NAME_PLAIN|UNIT_NAME_INSTANCE)) {
 530                 _cleanup_free_ char *path = NULL, *buf = NULL;
 531
 532                 path = unit_dbus_path_from_name(name);
 533                 if (!path)
 534                         return -ENOMEM;
 535
 536                 r = sd_bus_get_property_string(
 537                                 bus,
 538                                 "org.freedesktop.systemd1",
 539                                 path,
 540                                 "org.freedesktop.systemd1.Unit",
 541                                 "ActiveState",
 542                                 error,
 543                                 &buf);
 544                 if (r < 0)
 545                         return log_debug_errno(r, "Failed to retrieve unit state: %s", bus_error_message(error, r));
 546
 547                 return strv_contains((char**) active_states, buf);
 548         }
 549
 550         /* Otherwise we need to enumerate. But let's build the most restricted query we can */
 551         if (unit_name_is_valid(name, UNIT_NAME_TEMPLATE)) {
 552                 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
 553                 const char *at, *prefix, *joined;
 554
 555                 r = sd_bus_message_new_method_call(
 556                                 bus,
 557                                 &m,
 558                                 "org.freedesktop.systemd1",
 559                                 "/org/freedesktop/systemd1",
 560                                 "org.freedesktop.systemd1.Manager",
 561                                 "ListUnitsByPatterns");
 562                 if (r < 0)
 563                         return r;
 564
 565                 r = sd_bus_message_append_strv(m, (char**) active_states);
 566                 if (r < 0)
 567                         return r;
 568
 569                 at = strchr(name, '@');
 570                 assert(at);
 571
 572                 prefix = strndupa(name, at + 1 - name);
 573                 joined = strjoina(prefix, "*", at + 1);
 574
 575                 r = sd_bus_message_append_strv(m, STRV_MAKE(joined));
 576                 if (r < 0)
 577                         return r;
 578
 579                 r = sd_bus_call(bus, m, 0, error, &reply);
 580                 if (r < 0)
 581                         return log_debug_errno(r, "Failed to list units: %s", bus_error_message(error, r));
 582
 583                 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssssssouso)");
 584                 if (r < 0)
 585                         return r;
 586
 587                 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_STRUCT, "ssssssouso");
 588                 if (r < 0)
 589                         return r;
 590
 591                 return r > 0;
 592         }
 593
 594         return -EINVAL;
 595 }
 596
 597 static int portable_changes_add(
 598                 PortableChange **changes,
 599                 size_t *n_changes,
 600                 PortableChangeType type,
 601                 const char *path,
 602                 const char *source) {
 603
 604         _cleanup_free_ char *p = NULL, *s = NULL;
 605         PortableChange *c;
 606
 607         assert(path);
 608         assert(!changes == !n_changes);
 609
 610         if (!changes)
 611                 return 0;
 612
 613         c = reallocarray(*changes, *n_changes + 1, sizeof(PortableChange));
 614         if (!c)
 615                 return -ENOMEM;
 616         *changes = c;
 617
 618         p = strdup(path);
 619         if (!p)
 620                 return -ENOMEM;
 621
 622         path_simplify(p, false);
 623
 624         if (source) {
 625                 s = strdup(source);
 626                 if (!s)
 627                         return -ENOMEM;
 628
 629                 path_simplify(s, false);
 630         }
 631
 632         c[(*n_changes)++] = (PortableChange) {
 633                 .type = type,
 634                 .path = TAKE_PTR(p),
 635                 .source = TAKE_PTR(s),
 636         };
 637
 638         return 0;
 639 }
 640
 641 static int portable_changes_add_with_prefix(
 642                 PortableChange **changes,
 643                 size_t *n_changes,
 644                 PortableChangeType type,
 645                 const char *prefix,
 646                 const char *path,
 647                 const char *source) {
 648
 649         assert(path);
 650         assert(!changes == !n_changes);
 651
 652         if (!changes)
 653                 return 0;
 654
 655         if (prefix) {
 656                 path = strjoina(prefix, "/", path);
 657
 658                 if (source)
 659                         source = strjoina(prefix, "/", source);
 660         }
 661
 662         return portable_changes_add(changes, n_changes, type, path, source);
 663 }
 664
 665 void portable_changes_free(PortableChange *changes, size_t n_changes) {
 666         size_t i;
 667
 668         assert(changes || n_changes == 0);
 669
 670         for (i = 0; i < n_changes; i++) {
 671                 free(changes[i].path);
 672                 free(changes[i].source);
 673         }
 674
 675         free(changes);
 676 }
 677
 678 static int install_chroot_dropin(
 679                 const char *image_path,
 680                 ImageType type,
 681                 const PortableMetadata *m,
 682                 const char *dropin_dir,
 683                 char **ret_dropin,
 684                 PortableChange **changes,
 685                 size_t *n_changes) {
 686
 687         _cleanup_free_ char *text = NULL, *dropin = NULL;
 688         int r;
 689
 690         assert(image_path);
 691         assert(m);
 692         assert(dropin_dir);
 693
 694         dropin = strjoin(dropin_dir, "/20-portable.conf");
 695         if (!dropin)
 696                 return -ENOMEM;
 697
 698         text = strjoin(PORTABLE_DROPIN_MARKER_BEGIN, image_path, PORTABLE_DROPIN_MARKER_END "\n");
 699         if (!text)
 700                 return -ENOMEM;
 701
 702         if (endswith(m->name, ".service"))
 703                 if (!strextend(&text,
 704                                "\n"
 705                                "[Service]\n",
 706                                IN_SET(type, IMAGE_DIRECTORY, IMAGE_SUBVOLUME) ? "RootDirectory=" : "RootImage=", image_path, "\n"
 707                                "Environment=PORTABLE=", basename(image_path), "\n"
 708                                "LogExtraFields=PORTABLE=", basename(image_path), "\n",
 709                                NULL))
 710
 711                         return -ENOMEM;
 712
 713         r = write_string_file(dropin, text, WRITE_STRING_FILE_CREATE|WRITE_STRING_FILE_ATOMIC);
 714         if (r < 0)
 715                 return log_debug_errno(r, "Failed to write '%s': %m", dropin);
 716
 717         (void) portable_changes_add(changes, n_changes, PORTABLE_WRITE, dropin, NULL);
 718
 719         if (ret_dropin)
 720                 *ret_dropin = TAKE_PTR(dropin);
 721
 722         return 0;
 723 }
 724
 725 static int find_profile(const char *name, const char *unit, char **ret) {
 726         const char *p, *dot;
 727
 728         assert(name);
 729         assert(ret);
 730
 731         assert_se(dot = strrchr(unit, '.'));
 732
 733         NULSTR_FOREACH(p, profile_dirs) {
 734                 _cleanup_free_ char *joined;
 735
 736                 joined = strjoin(p, "/", name, "/", dot + 1, ".conf");
 737                 if (!joined)
 738                         return -ENOMEM;
 739
 740                 if (laccess(joined, F_OK) >= 0) {
 741                         *ret = TAKE_PTR(joined);
 742                         return 0;
 743                 }
 744
 745                 if (errno != ENOENT)
 746                         return -errno;
 747         }
 748
 749         return -ENOENT;
 750 }
 751
 752 static int install_profile_dropin(
 753                 const char *image_path,
 754                 const PortableMetadata *m,
 755                 const char *dropin_dir,
 756                 const char *profile,
 757                 PortableFlags flags,
 758                 char **ret_dropin,
 759                 PortableChange **changes,
 760                 size_t *n_changes) {
 761
 762         _cleanup_free_ char *dropin = NULL, *from = NULL;
 763         int r;
 764
 765         assert(image_path);
 766         assert(m);
 767         assert(dropin_dir);
 768
 769         if (!profile)
 770                 return 0;
 771
 772         r = find_profile(profile, m->name, &from);
 773         if (r < 0) {
 774                 if (r != -ENOENT)
 775                         return log_debug_errno(errno, "Profile '%s' is not accessible: %m", profile);
 776
 777                 log_debug_errno(errno, "Skipping link to profile '%s', as it does not exist: %m", profile);
 778                 return 0;
 779         }
 780
 781         dropin = strjoin(dropin_dir, "/10-profile.conf");
 782         if (!dropin)
 783                 return -ENOMEM;
 784
 785         if (flags & PORTABLE_PREFER_COPY) {
 786
 787                 r = copy_file_atomic(from, dropin, 0644, 0, 0, COPY_REFLINK);
 788                 if (r < 0)
 789                         return log_debug_errno(r, "Failed to copy %s %s %s: %m", from, special_glyph(SPECIAL_GLYPH_ARROW), dropin);
 790
 791                 (void) portable_changes_add(changes, n_changes, PORTABLE_COPY, dropin, from);
 792
 793         } else {
 794
 795                 if (symlink(from, dropin) < 0)
 796                         return log_debug_errno(errno, "Failed to link %s %s %s: %m", from, special_glyph(SPECIAL_GLYPH_ARROW), dropin);
 797
 798                 (void) portable_changes_add(changes, n_changes, PORTABLE_SYMLINK, dropin, from);
 799         }
 800
 801         if (ret_dropin)
 802                 *ret_dropin = TAKE_PTR(dropin);
 803
 804         return 0;
 805 }
 806
 807 static const char *attached_path(const LookupPaths *paths, PortableFlags flags) {
 808         const char *where;
 809
 810         assert(paths);
 811
 812         if (flags & PORTABLE_RUNTIME)
 813                 where = paths->runtime_attached;
 814         else
 815                 where = paths->persistent_attached;
 816
 817         assert(where);
 818         return where;
 819 }
 820
 821 static int attach_unit_file(
 822                 const LookupPaths *paths,
 823                 const char *image_path,
 824                 ImageType type,
 825                 const PortableMetadata *m,
 826                 const char *profile,
 827                 PortableFlags flags,
 828                 PortableChange **changes,
 829                 size_t *n_changes) {
 830
 831         _cleanup_(unlink_and_freep) char *chroot_dropin = NULL, *profile_dropin = NULL;
 832         _cleanup_(rmdir_and_freep) char *dropin_dir = NULL;
 833         const char *where, *path;
 834         int r;
 835
 836         assert(paths);
 837         assert(image_path);
 838         assert(m);
 839         assert(PORTABLE_METADATA_IS_UNIT(m));
 840
 841         where = attached_path(paths, flags);
 842
 843         (void) mkdir_parents(where, 0755);
 844         if (mkdir(where, 0755) < 0) {
 845                 if (errno != EEXIST)
 846                         return -errno;
 847         } else
 848                 (void) portable_changes_add(changes, n_changes, PORTABLE_MKDIR, where, NULL);
 849
 850         path = strjoina(where, "/", m->name);
 851         dropin_dir = strjoin(path, ".d");
 852         if (!dropin_dir)
 853                 return -ENOMEM;
 854
 855         if (mkdir(dropin_dir, 0755) < 0) {
 856                 if (errno != EEXIST)
 857                         return -errno;
 858         } else
 859                 (void) portable_changes_add(changes, n_changes, PORTABLE_MKDIR, dropin_dir, NULL);
 860
 861         /* We install the drop-ins first, and the actual unit file last to achieve somewhat atomic behaviour if PID 1
 862          * is reloaded while we are creating things here: as long as only the drop-ins exist the unit doesn't exist at
 863          * all for PID 1. */
 864
 865         r = install_chroot_dropin(image_path, type, m, dropin_dir, &chroot_dropin, changes, n_changes);
 866         if (r < 0)
 867                 return r;
 868
 869         r = install_profile_dropin(image_path, m, dropin_dir, profile, flags, &profile_dropin, changes, n_changes);
 870         if (r < 0)
 871                 return r;
 872
 873         if ((flags & PORTABLE_PREFER_SYMLINK) && m->source) {
 874
 875                 if (symlink(m->source, path) < 0)
 876                         return log_debug_errno(errno, "Failed to symlink unit file '%s': %m", path);
 877
 878                 (void) portable_changes_add(changes, n_changes, PORTABLE_SYMLINK, path, m->source);
 879
 880         } else {
 881                 _cleanup_(unlink_and_freep) char *tmp = NULL;
 882                 _cleanup_close_ int fd = -1;
 883
 884                 fd = open_tmpfile_linkable(where, O_WRONLY|O_CLOEXEC, &tmp);
 885                 if (fd < 0)
 886                         return log_debug_errno(fd, "Failed to create unit file '%s': %m", path);
 887
 888                 r = copy_bytes(m->fd, fd, UINT64_MAX, COPY_REFLINK);
 889                 if (r < 0)
 890                         return log_debug_errno(r, "Failed to copy unit file '%s': %m", path);
 891
 892                 if (fchmod(fd, 0644) < 0)
 893                         return log_debug_errno(errno, "Failed to change unit file access mode for '%s': %m", path);
 894
 895                 r = link_tmpfile(fd, tmp, path);
 896                 if (r < 0)
 897                         return log_debug_errno(r, "Failed to install unit file '%s': %m", path);
 898
 899                 tmp = mfree(tmp);
 900
 901                 (void) portable_changes_add(changes, n_changes, PORTABLE_COPY, path, m->source);
 902         }
 903
 904         /* All is established now, now let's disable any rollbacks */
 905         chroot_dropin = mfree(chroot_dropin);
 906         profile_dropin = mfree(profile_dropin);
 907         dropin_dir = mfree(dropin_dir);
 908
 909         return 0;
 910 }
 911
 912 static int image_symlink(
 913                 const char *image_path,
 914                 PortableFlags flags,
 915                 char **ret) {
 916
 917         const char *fn, *where;
 918         char *joined = NULL;
 919
 920         assert(image_path);
 921         assert(ret);
 922
 923         fn = last_path_component(image_path);
 924
 925         if (flags & PORTABLE_RUNTIME)
 926                 where = "/run/portables/";
 927         else
 928                 where = "/etc/portables/";
 929
 930         joined = strjoin(where, fn);
 931         if (!joined)
 932                 return -ENOMEM;
 933
 934         *ret = joined;
 935         return 0;
 936 }
 937
 938 static int install_image_symlink(
 939                 const char *image_path,
 940                 PortableFlags flags,
 941                 PortableChange **changes,
 942                 size_t *n_changes) {
 943
 944         _cleanup_free_ char *sl = NULL;
 945         int r;
 946
 947         assert(image_path);
 948
 949         /* If the image is outside of the image search also link it into it, so that it can be found with short image
 950          * names and is listed among the images. */
 951
 952         if (image_in_search_path(IMAGE_PORTABLE, image_path))
 953                 return 0;
 954
 955         r = image_symlink(image_path, flags, &sl);
 956         if (r < 0)
 957                 return log_debug_errno(r, "Failed to generate image symlink path: %m");
 958
 959         (void) mkdir_parents(sl, 0755);
 960
 961         if (symlink(image_path, sl) < 0)
 962                 return log_debug_errno(errno, "Failed to link %s %s %s: %m", image_path, special_glyph(SPECIAL_GLYPH_ARROW), sl);
 963
 964         (void) portable_changes_add(changes, n_changes, PORTABLE_SYMLINK, sl, image_path);
 965         return 0;
 966 }
 967
 968 int portable_attach(
 969                 sd_bus *bus,
 970                 const char *name_or_path,
 971                 char **matches,
 972                 const char *profile,
 973                 PortableFlags flags,
 974                 PortableChange **changes,
 975                 size_t *n_changes,
 976                 sd_bus_error *error) {
 977
 978         _cleanup_hashmap_free_ Hashmap *unit_files = NULL;
 979         _cleanup_(lookup_paths_free) LookupPaths paths = {};
 980         _cleanup_(image_unrefp) Image *image = NULL;
 981         PortableMetadata *item;
 982         Iterator iterator;
 983         int r;
 984
 985         assert(name_or_path);
 986
 987         r = image_find_harder(IMAGE_PORTABLE, name_or_path, &image);
 988         if (r < 0)
 989                 return r;
 990
 991         r = portable_extract_by_path(image->path, matches, NULL, &unit_files, error);
 992         if (r < 0)
 993                 return r;
 994
 995         r = lookup_paths_init(&paths, UNIT_FILE_SYSTEM, LOOKUP_PATHS_SPLIT_USR, NULL);
 996         if (r < 0)
 997                 return r;
 998
 999         HASHMAP_FOREACH(item, unit_files, iterator) {
1000                 r = unit_file_exists(UNIT_FILE_SYSTEM, &paths, item->name);
1001                 if (r < 0)
1002                         return sd_bus_error_set_errnof(error, r, "Failed to determine whether unit '%s' exists on the host: %m", item->name);
1003                 if (r > 0)
1004                         return sd_bus_error_setf(error, BUS_ERROR_UNIT_EXISTS, "Unit file '%s' exists on the host already, refusing.", item->name);
1005
1006                 r = unit_file_is_active(bus, item->name, error);
1007                 if (r < 0)
1008                         return r;
1009                 if (r > 0)
1010                         return sd_bus_error_setf(error, BUS_ERROR_UNIT_EXISTS, "Unit file '%s' is active already, refusing.", item->name);
1011         }
1012
1013         HASHMAP_FOREACH(item, unit_files, iterator) {
1014                 r = attach_unit_file(&paths, image->path, image->type, item, profile, flags, changes, n_changes);
1015                 if (r < 0)
1016                         return r;
1017         }
1018
1019         /* We don't care too much for the image symlink, it's just a convenience thing, it's not necessary for proper
1020          * operation otherwise. */
1021         (void) install_image_symlink(image->path, flags, changes, n_changes);
1022
1023         return 0;
1024 }
1025
1026 static bool marker_matches_image(const char *marker, const char *name_or_path) {
1027         const char *a;
1028
1029         assert(marker);
1030         assert(name_or_path);
1031
1032         a = last_path_component(marker);
1033
1034         if (image_name_is_valid(name_or_path)) {
1035                 const char *e;
1036
1037                 /* We shall match against an image name. In that case let's compare the last component, and optionally
1038                  * allow either a suffix of ".raw" or a series of "/". */
1039
1040                 e = startswith(a, name_or_path);
1041                 if (!e)
1042                         return false;
1043
1044                 return
1045                         e[strspn(e, "/")] == 0 ||
1046                         streq(e, ".raw");
1047         } else {
1048                 const char *b;
1049                 size_t l;
1050
1051                 /* We shall match against a path. Let's ignore any prefix here though, as often there are many ways to
1052                  * reach the same file. However, in this mode, let's validate any file suffix. */
1053
1054                 l = strcspn(a, "/");
1055                 b = last_path_component(name_or_path);
1056
1057                 if (strcspn(b, "/") != l)
1058                         return false;
1059
1060                 return memcmp(a, b, l) == 0;
1061         }
1062 }
1063
1064 static int test_chroot_dropin(
1065                 DIR *d,
1066                 const char *where,
1067                 const char *fname,
1068                 const char *name_or_path,
1069                 char **ret_marker) {
1070
1071         _cleanup_free_ char *line = NULL, *marker = NULL;
1072         _cleanup_fclose_ FILE *f = NULL;
1073         _cleanup_close_ int fd = -1;
1074         const char *p, *e, *k;
1075         int r;
1076
1077         assert(d);
1078         assert(where);
1079         assert(fname);
1080
1081         /* We recognize unis created from portable images via the drop-in we created for them */
1082
1083         p = strjoina(fname, ".d/20-portable.conf");
1084         fd = openat(dirfd(d), p, O_RDONLY|O_CLOEXEC);
1085         if (fd < 0) {
1086                 if (errno == ENOENT)
1087                         return 0;
1088
1089                 return log_debug_errno(errno, "Failed to open %s/%s: %m", where, p);
1090         }
1091
1092         r = fdopen_unlocked(fd, "r", &f);
1093         if (r < 0)
1094                 return log_debug_errno(r, "Failed to convert file handle: %m");
1095         TAKE_FD(fd);
1096
1097         r = read_line(f, LONG_LINE_MAX, &line);
1098         if (r < 0)
1099                 return log_debug_errno(r, "Failed to read from %s/%s: %m", where, p);
1100
1101         e = startswith(line, PORTABLE_DROPIN_MARKER_BEGIN);
1102         if (!e)
1103                 return 0;
1104
1105         k = endswith(e, PORTABLE_DROPIN_MARKER_END);
1106         if (!k)
1107                 return 0;
1108
1109         marker = strndup(e, k - e);
1110         if (!marker)
1111                 return -ENOMEM;
1112
1113         if (!name_or_path)
1114                 r = true;
1115         else
1116                 r = marker_matches_image(marker, name_or_path);
1117
1118         if (ret_marker)
1119                 *ret_marker = TAKE_PTR(marker);
1120
1121         return r;
1122 }
1123
1124 int portable_detach(
1125                 sd_bus *bus,
1126                 const char *name_or_path,
1127                 PortableFlags flags,
1128                 PortableChange **changes,
1129                 size_t *n_changes,
1130                 sd_bus_error *error) {
1131
1132         _cleanup_(lookup_paths_free) LookupPaths paths = {};
1133         _cleanup_set_free_free_ Set *unit_files = NULL, *markers = NULL;
1134         _cleanup_closedir_ DIR *d = NULL;
1135         const char *where, *item;
1136         Iterator iterator;
1137         struct dirent *de;
1138         int ret = 0;
1139         int r;
1140
1141         assert(name_or_path);
1142
1143         r = lookup_paths_init(&paths, UNIT_FILE_SYSTEM, LOOKUP_PATHS_SPLIT_USR, NULL);
1144         if (r < 0)
1145                 return r;
1146
1147         where = attached_path(&paths, flags);
1148
1149         d = opendir(where);
1150         if (!d) {
1151                 if (errno == ENOENT)
1152                         goto not_found;
1153
1154                 return log_debug_errno(errno, "Failed to open '%s' directory: %m", where);
1155         }
1156
1157         unit_files = set_new(&string_hash_ops);
1158         if (!unit_files)
1159                 return -ENOMEM;
1160
1161         markers = set_new(&path_hash_ops);
1162         if (!markers)
1163                 return -ENOMEM;
1164
1165         FOREACH_DIRENT(de, d, return log_debug_errno(errno, "Failed to enumerate '%s' directory: %m", where)) {
1166                 _cleanup_free_ char *marker = NULL;
1167                 UnitFileState state;
1168
1169                 if (!unit_name_is_valid(de->d_name, UNIT_NAME_ANY))
1170                         continue;
1171
1172                 /* Filter out duplicates */
1173                 if (set_get(unit_files, de->d_name))
1174                         continue;
1175
1176                 dirent_ensure_type(d, de);
1177                 if (!IN_SET(de->d_type, DT_LNK, DT_REG))
1178                         continue;
1179
1180                 r = test_chroot_dropin(d, where, de->d_name, name_or_path, &marker);
1181                 if (r < 0)
1182                         return r;
1183                 if (r == 0)
1184                         continue;
1185
1186                 r = unit_file_lookup_state(UNIT_FILE_SYSTEM, &paths, de->d_name, &state);
1187                 if (r < 0)
1188                         return log_debug_errno(r, "Failed to determine unit file state of '%s': %m", de->d_name);
1189                 if (!IN_SET(state, UNIT_FILE_STATIC, UNIT_FILE_DISABLED, UNIT_FILE_LINKED, UNIT_FILE_RUNTIME))
1190                         return sd_bus_error_setf(error, BUS_ERROR_UNIT_EXISTS, "Unit file '%s' is in state '%s', can't detach.", de->d_name, unit_file_state_to_string(state));
1191
1192                 r = unit_file_is_active(bus, de->d_name, error);
1193                 if (r < 0)
1194                         return r;
1195                 if (r > 0)
1196                         return sd_bus_error_setf(error, BUS_ERROR_UNIT_EXISTS, "Unit file '%s' is active, can't detach.", de->d_name);
1197
1198                 r = set_put_strdup(unit_files, de->d_name);
1199                 if (r < 0)
1200                         return log_debug_errno(r, "Failed to add unit name '%s' to set: %m", de->d_name);
1201
1202                 if (path_is_absolute(marker) &&
1203                     !image_in_search_path(IMAGE_PORTABLE, marker)) {
1204
1205                         r = set_ensure_allocated(&markers, &path_hash_ops);
1206                         if (r < 0)
1207                                 return r;
1208
1209                         r = set_put(markers, marker);
1210                         if (r >= 0)
1211                                 marker = NULL;
1212                         else if (r != -EEXIST)
1213                                 return r;
1214                 }
1215         }
1216
1217         if (set_isempty(unit_files))
1218                 goto not_found;
1219
1220         SET_FOREACH(item, unit_files, iterator) {
1221                 _cleanup_free_ char *md = NULL;
1222                 const char *suffix;
1223
1224                 if (unlinkat(dirfd(d), item, 0) < 0) {
1225                         log_debug_errno(errno, "Can't remove unit file %s/%s: %m", where, item);
1226
1227                         if (errno != ENOENT && ret >= 0)
1228                                 ret = -errno;
1229                 } else
1230                         portable_changes_add_with_prefix(changes, n_changes, PORTABLE_UNLINK, where, item, NULL);
1231
1232                 FOREACH_STRING(suffix, ".d/10-profile.conf", ".d/20-portable.conf") {
1233                         _cleanup_free_ char *dropin = NULL;
1234
1235                         dropin = strjoin(item, suffix);
1236                         if (!dropin)
1237                                 return -ENOMEM;
1238
1239                         if (unlinkat(dirfd(d), dropin, 0) < 0) {
1240                                 log_debug_errno(errno, "Can't remove drop-in %s/%s: %m", where, dropin);
1241
1242                                 if (errno != ENOENT && ret >= 0)
1243                                         ret = -errno;
1244                         } else
1245                                 portable_changes_add_with_prefix(changes, n_changes, PORTABLE_UNLINK, where, dropin, NULL);
1246                 }
1247
1248                 md = strjoin(item, ".d");
1249                 if (!md)
1250                         return -ENOMEM;
1251
1252                 if (unlinkat(dirfd(d), md, AT_REMOVEDIR) < 0) {
1253                         log_debug_errno(errno, "Can't remove drop-in directory %s/%s: %m", where, md);
1254
1255                         if (errno != ENOENT && ret >= 0)
1256                                 ret = -errno;
1257                 } else
1258                         portable_changes_add_with_prefix(changes, n_changes, PORTABLE_UNLINK, where, md, NULL);
1259         }
1260
1261         /* Now, also drop any image symlink, for images outside of the sarch path */
1262         SET_FOREACH(item, markers, iterator) {
1263                 _cleanup_free_ char *sl = NULL;
1264                 struct stat st;
1265
1266                 r = image_symlink(item, flags, &sl);
1267                 if (r < 0) {
1268                         log_debug_errno(r, "Failed to determine image symlink for '%s', ignoring: %m", item);
1269                         continue;
1270                 }
1271
1272                 if (lstat(sl, &st) < 0) {
1273                         log_debug_errno(errno, "Failed to stat '%s', ignoring: %m", sl);
1274                         continue;
1275                 }
1276
1277                 if (!S_ISLNK(st.st_mode)) {
1278                         log_debug("Image '%s' is not a symlink, ignoring.", sl);
1279                         continue;
1280                 }
1281
1282                 if (unlink(sl) < 0) {
1283                         log_debug_errno(errno, "Can't remove image symlink '%s': %m", sl);
1284
1285                         if (errno != ENOENT && ret >= 0)
1286                                 ret = -errno;
1287                 } else
1288                         portable_changes_add(changes, n_changes, PORTABLE_UNLINK, sl, NULL);
1289         }
1290
1291         /* Try to remove the unit file directory, if we can */
1292         if (rmdir(where) >= 0)
1293                 portable_changes_add(changes, n_changes, PORTABLE_UNLINK, where, NULL);
1294
1295         return ret;
1296
1297 not_found:
1298         log_debug("No unit files associated with '%s' found. Image not attached?", name_or_path);
1299         return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT, "No unit files associated with '%s' found. Image not attached?", name_or_path);
1300 }
1301
1302 static int portable_get_state_internal(
1303                 sd_bus *bus,
1304                 const char *name_or_path,
1305                 PortableFlags flags,
1306                 PortableState *ret,
1307                 sd_bus_error *error) {
1308
1309         _cleanup_(lookup_paths_free) LookupPaths paths = {};
1310         bool found_enabled = false, found_running = false;
1311         _cleanup_set_free_free_ Set *unit_files = NULL;
1312         _cleanup_closedir_ DIR *d = NULL;
1313         const char *where;
1314         struct dirent *de;
1315         int r;
1316
1317         assert(name_or_path);
1318         assert(ret);
1319
1320         r = lookup_paths_init(&paths, UNIT_FILE_SYSTEM, LOOKUP_PATHS_SPLIT_USR, NULL);
1321         if (r < 0)
1322                 return r;
1323
1324         where = attached_path(&paths, flags);
1325
1326         d = opendir(where);
1327         if (!d) {
1328                 if (errno == ENOENT) {
1329                         /* If the 'attached' directory doesn't exist at all, then we know for sure this image isn't attached. */
1330                         *ret = PORTABLE_DETACHED;
1331                         return 0;
1332                 }
1333
1334                 return log_debug_errno(errno, "Failed to open '%s' directory: %m", where);
1335         }
1336
1337         unit_files = set_new(&string_hash_ops);
1338         if (!unit_files)
1339                 return -ENOMEM;
1340
1341         FOREACH_DIRENT(de, d, return log_debug_errno(errno, "Failed to enumerate '%s' directory: %m", where)) {
1342                 UnitFileState state;
1343
1344                 if (!unit_name_is_valid(de->d_name, UNIT_NAME_ANY))
1345                         continue;
1346
1347                 /* Filter out duplicates */
1348                 if (set_get(unit_files, de->d_name))
1349                         continue;
1350
1351                 dirent_ensure_type(d, de);
1352                 if (!IN_SET(de->d_type, DT_LNK, DT_REG))
1353                         continue;
1354
1355                 r = test_chroot_dropin(d, where, de->d_name, name_or_path, NULL);
1356                 if (r < 0)
1357                         return r;
1358                 if (r == 0)
1359                         continue;
1360
1361                 r = unit_file_lookup_state(UNIT_FILE_SYSTEM, &paths, de->d_name, &state);
1362                 if (r < 0)
1363                         return log_debug_errno(r, "Failed to determine unit file state of '%s': %m", de->d_name);
1364                 if (!IN_SET(state, UNIT_FILE_STATIC, UNIT_FILE_DISABLED, UNIT_FILE_LINKED, UNIT_FILE_LINKED_RUNTIME))
1365                         found_enabled = true;
1366
1367                 r = unit_file_is_active(bus, de->d_name, error);
1368                 if (r < 0)
1369                         return r;
1370                 if (r > 0)
1371                         found_running = true;
1372
1373                 r = set_put_strdup(unit_files, de->d_name);
1374                 if (r < 0)
1375                         return log_debug_errno(r, "Failed to add unit name '%s' to set: %m", de->d_name);
1376         }
1377
1378         *ret = found_running ? (!set_isempty(unit_files) && (flags & PORTABLE_RUNTIME) ? PORTABLE_RUNNING_RUNTIME : PORTABLE_RUNNING) :
1379                 found_enabled ?            (flags & PORTABLE_RUNTIME ? PORTABLE_ENABLED_RUNTIME : PORTABLE_ENABLED) :
1380                 !set_isempty(unit_files) ? (flags & PORTABLE_RUNTIME ? PORTABLE_ATTACHED_RUNTIME : PORTABLE_ATTACHED) : PORTABLE_DETACHED;
1381
1382         return 0;
1383 }
1384
1385 int portable_get_state(
1386                 sd_bus *bus,
1387                 const char *name_or_path,
1388                 PortableFlags flags,
1389                 PortableState *ret,
1390                 sd_bus_error *error) {
1391
1392         PortableState state;
1393         int r;
1394
1395         assert(name_or_path);
1396         assert(ret);
1397
1398         /* We look for matching units twice: once in the regular directories, and once in the runtime directories — but
1399          * the latter only if we didn't find anything in the former. */
1400
1401         r = portable_get_state_internal(bus, name_or_path, flags & ~PORTABLE_RUNTIME, &state, error);
1402         if (r < 0)
1403                 return r;
1404
1405         if (state == PORTABLE_DETACHED) {
1406                 r = portable_get_state_internal(bus, name_or_path, flags | PORTABLE_RUNTIME, &state, error);
1407                 if (r < 0)
1408                         return r;
1409         }
1410
1411         *ret = state;
1412         return 0;
1413 }
1414
1415 int portable_get_profiles(char ***ret) {
1416         assert(ret);
1417
1418         return conf_files_list_nulstr(ret, NULL, NULL, CONF_FILES_DIRECTORY|CONF_FILES_BASENAME|CONF_FILES_FILTER_MASKED, profile_dirs);
1419 }
1420
1421 static const char* const portable_change_type_table[_PORTABLE_CHANGE_TYPE_MAX] = {
1422         [PORTABLE_COPY] = "copy",
1423         [PORTABLE_MKDIR] = "mkdir",
1424         [PORTABLE_SYMLINK] = "symlink",
1425         [PORTABLE_UNLINK] = "unlink",
1426         [PORTABLE_WRITE] = "write",
1427 };
1428
1429 DEFINE_STRING_TABLE_LOOKUP(portable_change_type, PortableChangeType);
1430
1431 static const char* const portable_state_table[_PORTABLE_STATE_MAX] = {
1432         [PORTABLE_DETACHED] = "detached",
1433         [PORTABLE_ATTACHED] = "attached",
1434         [PORTABLE_ATTACHED_RUNTIME] = "attached-runtime",
1435         [PORTABLE_ENABLED] = "enabled",
1436         [PORTABLE_ENABLED_RUNTIME] = "enabled-runtime",
1437         [PORTABLE_RUNNING] = "running",
1438         [PORTABLE_RUNNING_RUNTIME] = "running-runtime",
1439 };
1440
1441 DEFINE_STRING_TABLE_LOOKUP(portable_state, PortableState);