src/portable/portable.c

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