HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/portable/portable.c

114,308 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 0d42a3c41aa6ccdbda76b016df825fad2759375e

Lines 1001–2000 of 2,720

                                return log_debug_errno(r, "Failed to merge extension image policies: %m");
 
                        free_and_replace(pinned_ext_image_policy, intersected_policy);
                }
 
                if (!validate_extension && !ret_valid_prefixes && !ret_extension_releases)
                        continue;
 
                r = load_env_file_pairs_fd(extension_release_meta->fd, extension_release_meta->name, &extension_release);
                if (r < 0)
                        return r;
 
                if (validate_extension) {
                        r = extension_release_validate(ext->path, id, id_like, version_id, sysext_level, "portable", extension_release, IMAGE_SYSEXT);
                        if (r < 0)
                                r = extension_release_validate(ext->path, id, id_like, version_id, confext_level, "portable", extension_release, IMAGE_CONFEXT);
 
                        if (r == 0)
                                return sd_bus_error_set_errnof(error, ESTALE, "Image %s extension-release metadata does not match the root's", ext->path);
                        if (r < 0)
                                return sd_bus_error_set_errnof(error, r, "Failed to compare image %s extension-release metadata with the root's os-release: %m", ext->path);
                }
 
                e = strv_env_pairs_get(extension_release, "PORTABLE_PREFIXES");
                if (e) {
                        r = strv_split_and_extend(&valid_prefixes, e, WHITESPACE, /* filter_duplicates= */ true);
                        if (r < 0)
                                return r;
                }
 
                if (ret_extension_releases) {
                        r = ordered_hashmap_put(extension_releases, ext->name, extension_release_meta);
                        if (r < 0)
                                return r;
                        TAKE_PTR(extension_release_meta);
                }
        }
 
        strv_sort(valid_prefixes);
 
        if (ret_image)
                *ret_image = TAKE_PTR(image);
        if (ret_extension_images)
                *ret_extension_images = TAKE_PTR(extension_images);
        if (ret_extension_releases)
                *ret_extension_releases = TAKE_PTR(extension_releases);
        if (ret_os_release)
                *ret_os_release = TAKE_PTR(os_release);
        if (ret_unit_files)
                *ret_unit_files = TAKE_PTR(unit_files);
        if (ret_valid_prefixes)
                *ret_valid_prefixes = TAKE_PTR(valid_prefixes);
        if (ret_pinned_root_image_policy)
                *ret_pinned_root_image_policy = TAKE_PTR(pinned_root_image_policy);
        if (ret_pinned_ext_image_policy)
                *ret_pinned_ext_image_policy = TAKE_PTR(pinned_ext_image_policy);
 
        return 0;
}
 
int portable_extract(
                RuntimeScope scope,
                const char *name_or_path,
                char **matches,
                char **extension_image_paths,
                const ImagePolicy *image_policy,
                PortableFlags flags,
                PortableMetadata **ret_os_release,
                OrderedHashmap **ret_extension_releases,
                Hashmap **ret_unit_files,
                char ***ret_valid_prefixes,
                sd_bus_error *error) {
 
        _cleanup_(portable_metadata_unrefp) PortableMetadata *os_release = NULL;
        _cleanup_ordered_hashmap_free_ OrderedHashmap *extension_images = NULL, *extension_releases = NULL;
        _cleanup_hashmap_free_ Hashmap *unit_files = NULL;
        _cleanup_strv_free_ char **valid_prefixes = NULL;
        _cleanup_(image_unrefp) Image *image = NULL;
        int r;
 
        assert(name_or_path);
 
        r = extract_image_and_extensions(
                        scope,
                        name_or_path,
                        matches,
                        extension_image_paths,
                        /* validate_extension= */ false,
                        /* relax_extension_release_check= */ FLAGS_SET(flags, PORTABLE_FORCE_EXTENSION),
                        image_policy,
                        &image,
                        &extension_images,
                        &extension_releases,
                        &os_release,
                        &unit_files,
                        ret_valid_prefixes ? &valid_prefixes : NULL,
                        /* pinned_root_image_policy= */ NULL,
                        /* pinned_ext_image_policy= */ NULL,
                        error);
        if (r < 0)
                return r;
 
        if (hashmap_isempty(unit_files)) {
                _cleanup_free_ char *extensions = strv_join(extension_image_paths, ", ");
                if (!extensions)
                        return -ENOMEM;
 
                return sd_bus_error_setf(error,
                                         BUS_ERROR_NO_MATCHING_UNIT_FILES,
                                         "Couldn't find any matching unit files in image '%s%s%s', refusing.",
                                         image->path,
                                         isempty(extensions) ? "" : "' or any of its extensions '",
                                         isempty(extensions) ? "" : extensions);
        }
 
        if (ret_os_release)
                *ret_os_release = TAKE_PTR(os_release);
        if (ret_extension_releases)
                *ret_extension_releases = TAKE_PTR(extension_releases);
        if (ret_unit_files)
                *ret_unit_files = TAKE_PTR(unit_files);
        if (ret_valid_prefixes)
                *ret_valid_prefixes = TAKE_PTR(valid_prefixes);
 
        return 0;
}
 
static int unit_file_is_active(
                sd_bus *bus,
                const char *name,
                sd_bus_error *error) {
 
        static const char *const active_states[] = {
                "activating",
                "active",
                "reloading",
                "deactivating",
                NULL,
        };
        int r;
 
        if (!bus)
                return false;
 
        /* If we are looking at a plain or instance things are easy, we can just query the state */
        if (unit_name_is_valid(name, UNIT_NAME_PLAIN|UNIT_NAME_INSTANCE)) {
                _cleanup_free_ char *path = NULL, *buf = NULL;
 
                path = unit_dbus_path_from_name(name);
                if (!path)
                        return -ENOMEM;
 
                r = sd_bus_get_property_string(
                                bus,
                                "org.freedesktop.systemd1",
                                path,
                                "org.freedesktop.systemd1.Unit",
                                "ActiveState",
                                error,
                                &buf);
                if (r < 0)
                        return log_debug_errno(r, "Failed to retrieve unit state: %s", bus_error_message(error, r));
 
                return strv_contains((char**) active_states, buf);
        }
 
        /* Otherwise we need to enumerate. But let's build the most restricted query we can */
        if (unit_name_is_valid(name, UNIT_NAME_TEMPLATE)) {
                _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
                const char *at, *prefix, *joined;
 
                r = bus_message_new_method_call(bus, &m, bus_systemd_mgr, "ListUnitsByPatterns");
                if (r < 0)
                        return r;
 
                r = sd_bus_message_append_strv(m, (char**) active_states);
                if (r < 0)
                        return r;
 
                at = strchr(name, '@');
                assert(at);
 
                prefix = strndupa_safe(name, at + 1 - name);
                joined = strjoina(prefix, "*", at + 1);
 
                r = sd_bus_message_append_strv(m, STRV_MAKE(joined));
                if (r < 0)
                        return r;
 
                r = sd_bus_call(bus, m, 0, error, &reply);
                if (r < 0)
                        return log_debug_errno(r, "Failed to list units: %s", bus_error_message(error, r));
 
                r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssssssouso)");
                if (r < 0)
                        return r;
 
                r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_STRUCT, "ssssssouso");
                if (r < 0)
                        return r;
 
                return r > 0;
        }
 
        return -EINVAL;
}
 
static int portable_changes_add(
                PortableChange **changes,
                size_t *n_changes,
                int type_or_errno, /* PORTABLE_COPY, PORTABLE_SYMLINK, … if positive, or errno if negative */
                const char *path,
                const char *source) {
 
        _cleanup_free_ char *p = NULL, *s = NULL;
        int r;
 
        assert(path);
        assert(!changes == !n_changes);
 
        if (type_or_errno >= 0)
                assert(type_or_errno < _PORTABLE_CHANGE_TYPE_MAX);
        else
                assert(type_or_errno >= -ERRNO_MAX);
 
        if (!changes)
                return 0;
 
        if (!GREEDY_REALLOC(*changes, *n_changes + 1))
                return -ENOMEM;
 
        r = path_simplify_alloc(path, &p);
        if (r < 0)
                return r;
 
        r = path_simplify_alloc(source, &s);
        if (r < 0)
                return r;
 
        (*changes)[(*n_changes)++] = (PortableChange) {
                .type_or_errno = type_or_errno,
                .path = TAKE_PTR(p),
                .source = TAKE_PTR(s),
        };
 
        return 0;
}
 
static int portable_changes_add_with_prefix(
                PortableChange **changes,
                size_t *n_changes,
                int type_or_errno,
                const char *prefix,
                const char *path,
                const char *source) {
 
        _cleanup_free_ char *path_buf = NULL, *source_buf = NULL;
 
        assert(path);
        assert(!changes == !n_changes);
 
        if (!changes)
                return 0;
 
        if (prefix) {
                path_buf = path_join(prefix, path);
                if (!path_buf)
                        return -ENOMEM;
 
                path = path_buf;
 
                if (source) {
                        source_buf = path_join(prefix, source);
                        if (!source_buf)
                                return -ENOMEM;
 
                        source = source_buf;
                }
        }
 
        return portable_changes_add(changes, n_changes, type_or_errno, path, source);
}
 
static void portable_change_done(PortableChange *change) {
        assert(change);
        change->path = mfree(change->path);
        change->source = mfree(change->source);
}
 
DEFINE_ARRAY_FREE_FUNC(portable_changes_free, PortableChange, portable_change_done);
 
static const char *root_setting_from_image(ImageType type) {
        switch (type) {
        case IMAGE_DIRECTORY:
        case IMAGE_SUBVOLUME:
                return "RootDirectory=";
 
        case IMAGE_RAW:
        case IMAGE_BLOCK:
                return "RootImage=";
 
        case IMAGE_MSTACK:
                return "RootMStack=";
 
        default:
                return NULL;
        }
}
 
static const char *extension_setting_from_image(ImageType type) {
        switch (type) {
        case IMAGE_DIRECTORY:
        case IMAGE_SUBVOLUME:
                return "ExtensionDirectories=";
 
        case IMAGE_RAW:
        case IMAGE_BLOCK:
                return "ExtensionImages=";
 
        default:
                return NULL;
        }
}
 
static int make_marker_text(const char *image_path, OrderedHashmap *extension_images, char **ret_text) {
        _cleanup_free_ char *text = NULL, *escaped_image_path = NULL;
        Image *ext;
 
        assert(image_path);
        assert(ret_text);
 
        escaped_image_path = xescape(image_path, ":");
        if (!escaped_image_path)
                return -ENOMEM;
 
        /* If the image is layered, include all layers in the marker as a colon-separated
         * list of paths, so that we can do exact matches on removal. */
        text = strjoin(PORTABLE_DROPIN_MARKER_BEGIN, escaped_image_path);
        if (!text)
                return -ENOMEM;
 
        ORDERED_HASHMAP_FOREACH(ext, extension_images) {
                _cleanup_free_ char *escaped = NULL;
 
                escaped = xescape(ext->path, ":");
                if (!escaped)
                        return -ENOMEM;
 
                if (!strextend(&text, ":", escaped))
                        return -ENOMEM;
        }
 
        if (!strextend(&text, PORTABLE_DROPIN_MARKER_END "\n"))
                return -ENOMEM;
 
        *ret_text = TAKE_PTR(text);
        return 0;
}
 
static int append_release_log_fields(
                char **text,
                const PortableMetadata *release,
                ImageClass type,
                const char *field_name) {
 
        static const char *const field_versions[_IMAGE_CLASS_MAX][4]= {
                 [IMAGE_PORTABLE] = { "IMAGE_VERSION", "VERSION_ID", "BUILD_ID", NULL },
                 [IMAGE_SYSEXT] = { "SYSEXT_IMAGE_VERSION", "SYSEXT_VERSION_ID", "SYSEXT_BUILD_ID", NULL },
                 [IMAGE_CONFEXT] = { "CONFEXT_IMAGE_VERSION", "CONFEXT_VERSION_ID", "CONFEXT_BUILD_ID", NULL },
        };
        static const char *const field_ids[_IMAGE_CLASS_MAX][3]= {
                 [IMAGE_PORTABLE] = { "IMAGE_ID", "ID", NULL },
                 [IMAGE_SYSEXT] = { "SYSEXT_IMAGE_ID", "SYSEXT_ID", NULL },
                 [IMAGE_CONFEXT] = { "CONFEXT_IMAGE_ID", "CONFEXT_ID", NULL },
        };
        _cleanup_strv_free_ char **fields = NULL;
        const char *id = NULL, *version = NULL;
        int r;
 
        assert(IN_SET(type, IMAGE_PORTABLE, IMAGE_SYSEXT, IMAGE_CONFEXT));
        assert(!strv_isempty((char *const *)field_ids[type]));
        assert(!strv_isempty((char *const *)field_versions[type]));
        assert(field_name);
        assert(text);
 
        if (!release)
                return 0; /* Nothing to do. */
 
        r = load_env_file_pairs_fd(release->fd, release->name, &fields);
        if (r < 0)
                return log_debug_errno(r, "Failed to parse '%s': %m", release->name);
 
        /* Find an ID first, in order of preference from more specific to less specific: IMAGE_ID -> ID */
        id = strv_find_first_field((char *const *)field_ids[type], fields);
        if (id && string_has_cc(id, /* ok= */ NULL)) {
                log_debug("os-release file '%s' contains control characters in the ID field, skipping.",
                          release->name);
                id = NULL;
        }
 
        /* Then the version, same logic, prefer the more specific one */
        version = strv_find_first_field((char *const *)field_versions[type], fields);
        if (version && string_has_cc(version, /* ok= */ NULL)) {
                log_debug("os-release file '%s' contains control characters in the version field, skipping.",
                          release->name);
                version = NULL;
        }
 
        /* If there's no valid version to be found, simply omit it. */
        if (!id && !version)
                return 0;
 
        if (!strextend(text,
                       "LogExtraFields=",
                       field_name,
                       "=",
                       strempty(id),
                       id && version ? "_" : "",
                       strempty(version),
                       "\n"))
                return -ENOMEM;
 
        return 0;
}
 
static int install_chroot_dropin(
                const char *image_path,
                ImageType type,
                OrderedHashmap *extension_images,
                OrderedHashmap *extension_releases,
                const ImagePolicy *pinned_root_image_policy,
                const ImagePolicy *pinned_ext_image_policy,
                const PortableMetadata *m,
                const PortableMetadata *os_release,
                const char *dropin_dir,
                PortableFlags flags,
                char **ret_dropin,
                PortableChange **changes,
                size_t *n_changes) {
 
        _cleanup_free_ char *text = NULL, *dropin = NULL;
        int r;
 
        assert(image_path);
        assert(m);
        assert(dropin_dir);
 
        dropin = path_join(dropin_dir, "20-portable.conf");
        if (!dropin)
                return -ENOMEM;
 
        r = make_marker_text(image_path, extension_images, &text);
        if (r < 0)
                return log_debug_errno(r, "Failed to generate marker string for portable drop-in: %m");
 
        if (endswith(m->name, ".service")) {
                const char *root_type;
                _cleanup_free_ char *base_name = NULL;
                Image *ext;
 
                root_type = root_setting_from_image(type);
                if (!root_type)
                        return log_debug_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Image type '%s' not supported as portable service.", image_type_to_string(type));
 
                r = path_extract_filename(m->image_path ?: image_path, &base_name);
                if (r < 0)
                        return log_debug_errno(r, "Failed to extract basename from '%s': %m", m->image_path ?: image_path);
 
                if (!strextend(&text,
                               "\n"
                               "[Service]\n",
                               root_type, image_path, "\n"
                               "Environment=PORTABLE=", base_name, "\n"
                               "LogExtraFields=PORTABLE=", base_name, "\n"))
                        return -ENOMEM;
 
                if (pinned_root_image_policy) {
                        _cleanup_free_ char *policy_str = NULL;
 
                        r = image_policy_to_string(pinned_root_image_policy, /* simplify= */ true, &policy_str);
                        if (r < 0)
                                return log_debug_errno(r, "Failed to serialize pinned image policy: %m");
 
                        if (!strextend(&text,
                                       "RootImagePolicy=", policy_str, "\n"))
                                return -ENOMEM;
                }
 
                /* If we have a single image then PORTABLE= will point to it, so we add
                 * PORTABLE_NAME_AND_VERSION= with the os-release fields and we are done. But if we have
                 * extensions, PORTABLE= will point to the image where the current unit was found in. So we
                 * also list PORTABLE_ROOT= and PORTABLE_ROOT_NAME_AND_VERSION= for the base image, and
                 * PORTABLE_EXTENSION= and PORTABLE_EXTENSION_NAME_AND_VERSION= for each extension, so that
                 * all needed metadata is available. */
                if (ordered_hashmap_isempty(extension_images))
                        r = append_release_log_fields(&text, os_release, IMAGE_PORTABLE, "PORTABLE_NAME_AND_VERSION");
                else {
                        _cleanup_free_ char *root_base_name = NULL;
 
                        r = path_extract_filename(image_path, &root_base_name);
                        if (r < 0)
                                return log_debug_errno(r, "Failed to extract basename from '%s': %m", image_path);
 
                        if (!strextend(&text,
                                       "Environment=PORTABLE_ROOT=", root_base_name, "\n",
                                       "LogExtraFields=PORTABLE_ROOT=", root_base_name, "\n"))
                                return -ENOMEM;
 
                        r = append_release_log_fields(&text, os_release, IMAGE_PORTABLE, "PORTABLE_ROOT_NAME_AND_VERSION");
                }
                if (r < 0)
                        return r;
 
                ORDERED_HASHMAP_FOREACH(ext, extension_images) {
 
                        const char *extension_setting = extension_setting_from_image(ext->type);
                        if (!extension_setting)
                                return log_debug_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Image type '%s' not supported for extensions: %m", image_type_to_string(ext->type));
 
                        _cleanup_free_ char *extension_base_name = NULL;
                        r = path_extract_filename(ext->path, &extension_base_name);
                        if (r < 0)
                                return log_debug_errno(r, "Failed to extract basename from '%s': %m", ext->path);
 
                        if (!strextend(&text,
                                       "\n",
                                       extension_setting,
                                       ext->path,
                                       /* With --force tell PID1 to avoid enforcing that the image <name> and
                                        * extension-release.<name> have to match. */
                                       !IN_SET(ext->type, IMAGE_DIRECTORY, IMAGE_SUBVOLUME) &&
                                           FLAGS_SET(flags, PORTABLE_FORCE_EXTENSION) ?
                                               ":x-systemd.relax-extension-release-check\n" :
                                               "\n",
                                       /* In PORTABLE= we list the 'main' image name for this unit
                                        * (the image where the unit was extracted from), but we are
                                        * stacking multiple images, so list those too. */
                                       "LogExtraFields=PORTABLE_EXTENSION=", extension_base_name, "\n"))
                                return -ENOMEM;
 
                        if (pinned_ext_image_policy && !IN_SET(ext->type, IMAGE_DIRECTORY, IMAGE_SUBVOLUME)) {
                                _cleanup_free_ char *policy_str = NULL;
 
                                r = image_policy_to_string(pinned_ext_image_policy, /* simplify= */ true, &policy_str);
                                if (r < 0)
                                        return log_debug_errno(r, "Failed to serialize pinned image policy: %m");
 
                                if (!strextend(&text,
                                               "ExtensionImagePolicy=", policy_str, "\n"))
                                        return -ENOMEM;
                        }
 
                        /* Look for image/version identifiers in the extension release files. We
                         * look for all possible IDs, but typically only 1 or 2 will be set, so
                         * the number of fields added shouldn't be too large. We prefix the DDI
                         * name to the value, so that we can add the same field multiple times and
                         * still be able to identify what applies to what. */
                        r = append_release_log_fields(&text,
                                                      ordered_hashmap_get(extension_releases, ext->name),
                                                      IMAGE_SYSEXT,
                                                      "PORTABLE_EXTENSION_NAME_AND_VERSION");
                        if (r < 0)
                                return r;
 
                        r = append_release_log_fields(&text,
                                                      ordered_hashmap_get(extension_releases, ext->name),
                                                      IMAGE_CONFEXT,
                                                      "PORTABLE_EXTENSION_NAME_AND_VERSION");
                        if (r < 0)
                                return r;
                }
        }
 
        r = write_string_file(dropin, text, WRITE_STRING_FILE_CREATE|WRITE_STRING_FILE_ATOMIC|WRITE_STRING_FILE_SYNC);
        if (r < 0)
                return log_debug_errno(r, "Failed to write '%s': %m", dropin);
 
        (void) portable_changes_add(changes, n_changes, PORTABLE_WRITE, dropin, NULL);
 
        if (ret_dropin)
                *ret_dropin = TAKE_PTR(dropin);
 
        return 0;
}
 
static int install_profile_dropin(
                RuntimeScope scope,
                const char *image_path,
                const PortableMetadata *m,
                const char *dropin_dir,
                const char *profile,
                PortableFlags flags,
                char **ret_dropin,
                PortableChange **changes,
                size_t *n_changes) {
 
        _cleanup_free_ char *dropin = NULL, *from = NULL;
        int r;
 
        assert(image_path);
        assert(m);
        assert(dropin_dir);
 
        if (!profile)
                return 0;
 
        r = find_portable_profile(scope, profile, m->name, &from);
        if (r < 0) {
                if (r != -ENOENT)
                        return log_debug_errno(r, "Profile '%s' is not accessible: %m", profile);
 
                log_debug_errno(r, "Skipping link to profile '%s', as it does not exist: %m", profile);
                return 0;
        }
 
        dropin = path_join(dropin_dir, "10-profile.conf");
        if (!dropin)
                return -ENOMEM;
 
        if (flags & PORTABLE_PREFER_COPY) {
                CopyFlags copy_flags = COPY_FSYNC;
 
                if (flags & PORTABLE_FORCE_ATTACH)
                        copy_flags |= COPY_REPLACE;
 
                r = copy_file_atomic(from, dropin, 0644, copy_flags);
                if (r < 0)
                        return log_debug_errno(r, "Failed to copy %s %s %s: %m", from, glyph(GLYPH_ARROW_RIGHT), dropin);
 
                (void) portable_changes_add(changes, n_changes, PORTABLE_COPY, dropin, from);
 
        } else {
 
                if (flags & PORTABLE_FORCE_ATTACH)
                        r = symlink_atomic(from, dropin);
                else
                        r = RET_NERRNO(symlink(from, dropin));
                if (r < 0)
                        return log_debug_errno(r, "Failed to link %s %s %s: %m", from, glyph(GLYPH_ARROW_RIGHT), dropin);
 
                (void) portable_changes_add(changes, n_changes, PORTABLE_SYMLINK, dropin, from);
        }
 
        if (ret_dropin)
                *ret_dropin = TAKE_PTR(dropin);
 
        return 0;
}
 
static const char *attached_path(const LookupPaths *paths, PortableFlags flags) {
        const char *where;
 
        assert(paths);
 
        if (flags & PORTABLE_RUNTIME)
                where = paths->runtime_attached;
        else
                where = paths->persistent_attached;
 
        assert(where);
        return where;
}
 
static int attach_unit_file(
                RuntimeScope scope,
                const LookupPaths *paths,
                const char *image_path,
                ImageType type,
                OrderedHashmap *extension_images,
                OrderedHashmap *extension_releases,
                const ImagePolicy *pinned_root_image_policy,
                const ImagePolicy *pinned_ext_image_policy,
                const PortableMetadata *m,
                const PortableMetadata *os_release,
                const char *profile,
                PortableFlags flags,
                PortableChange **changes,
                size_t *n_changes) {
 
        _cleanup_(unlink_and_freep) char *chroot_dropin = NULL, *profile_dropin = NULL;
        _cleanup_(rmdir_and_freep) char *dropin_dir = NULL;
        _cleanup_free_ char *path = NULL;
        const char *where;
        int r;
 
        assert(paths);
        assert(image_path);
        assert(m);
        assert(PORTABLE_METADATA_IS_UNIT(m));
 
        where = attached_path(paths, flags);
 
        (void) mkdir_parents(where, 0755);
        if (mkdir(where, 0755) < 0) {
                if (errno != EEXIST)
                        return log_debug_errno(errno, "Failed to create attach directory %s: %m", where);
        } else
                (void) portable_changes_add(changes, n_changes, PORTABLE_MKDIR, where, NULL);
 
        path = path_join(where, m->name);
        if (!path)
                return -ENOMEM;
 
        dropin_dir = strjoin(path, ".d");
        if (!dropin_dir)
                return -ENOMEM;
 
        if (mkdir(dropin_dir, 0755) < 0) {
                if (errno != EEXIST)
                        return log_debug_errno(errno, "Failed to create drop-in directory %s: %m", dropin_dir);
        } else
                (void) portable_changes_add(changes, n_changes, PORTABLE_MKDIR, dropin_dir, NULL);
 
        /* We install the drop-ins first, and the actual unit file last to achieve somewhat atomic behaviour if PID 1
         * is reloaded while we are creating things here: as long as only the drop-ins exist the unit doesn't exist at
         * all for PID 1. */
 
        r = install_chroot_dropin(
                        image_path,
                        type,
                        extension_images,
                        extension_releases,
                        pinned_root_image_policy,
                        pinned_ext_image_policy,
                        m,
                        os_release,
                        dropin_dir,
                        flags,
                        &chroot_dropin,
                        changes,
                        n_changes);
        if (r < 0)
                return r;
 
        r = install_profile_dropin(scope, image_path, m, dropin_dir, profile, flags, &profile_dropin, changes, n_changes);
        if (r < 0)
                return r;
 
        if ((flags & PORTABLE_PREFER_SYMLINK) && m->source) {
 
                if (flags & PORTABLE_FORCE_ATTACH)
                        r = symlink_atomic(m->source, path);
                else
                        r = RET_NERRNO(symlink(m->source, path));
                if (r < 0)
                        return log_debug_errno(r, "Failed to symlink unit file '%s': %m", path);
 
                (void) portable_changes_add(changes, n_changes, PORTABLE_SYMLINK, path, m->source);
 
        } else {
                LinkTmpfileFlags link_flags = LINK_TMPFILE_SYNC;
                _cleanup_(unlink_and_freep) char *tmp = NULL;
                _cleanup_close_ int fd = -EBADF;
 
                if (flags & PORTABLE_FORCE_ATTACH)
                        link_flags |= LINK_TMPFILE_REPLACE;
 
                (void) mac_selinux_create_file_prepare_label(path, m->selinux_label);
 
                fd = open_tmpfile_linkable(path, O_WRONLY|O_CLOEXEC, &tmp);
                mac_selinux_create_file_clear(); /* Clear immediately in case of errors */
                if (fd < 0)
                        return log_debug_errno(fd, "Failed to create unit file '%s': %m", path);
 
                r = copy_bytes(m->fd, fd, UINT64_MAX, /* copy_flags= */ 0);
                if (r < 0)
                        return log_debug_errno(r, "Failed to copy unit file '%s': %m", path);
 
                if (fchmod(fd, 0644) < 0)
                        return log_debug_errno(errno, "Failed to change unit file access mode for '%s': %m", path);
 
                r = link_tmpfile(fd, tmp, path, link_flags);
                if (r < 0)
                        return log_debug_errno(r, "Failed to install unit file '%s': %m", path);
 
                tmp = mfree(tmp);
 
                (void) portable_changes_add(changes, n_changes, PORTABLE_COPY, path, m->source);
        }
 
        /* All is established now, now let's disable any rollbacks */
        chroot_dropin = mfree(chroot_dropin);
        profile_dropin = mfree(profile_dropin);
        dropin_dir = mfree(dropin_dir);
 
        return 0;
}
 
static int image_target_path(RuntimeScope scope, const char *image_path, PortableFlags flags, char **ret) {
        _cleanup_free_ char *where = NULL;
        const char *fn;
        char *joined = NULL;
        int r;
 
        assert(image_path);
        assert(ret);
 
        fn = last_path_component(image_path);
 
        if (flags & PORTABLE_RUNTIME)
                r = runtime_directory_generic(scope, "portables", &where);
        else
                r = config_directory_generic(scope, "portables", &where);
        if (r < 0)
                return r;
 
        joined = path_join(where, fn);
        if (!joined)
                return -ENOMEM;
 
        *ret = joined;
        return 0;
}
 
static int install_image(
                RuntimeScope scope,
                const char *image_path,
                PortableFlags flags,
                PortableChange **changes,
                size_t *n_changes) {
 
        _cleanup_free_ char *target = NULL;
        int r;
 
        assert(scope < _RUNTIME_SCOPE_MAX);
        assert(image_path);
 
        /* If the image is outside of the image search also link it into it, so that it can be found with
         * short image names and is listed among the images. If we are operating in mixed mode, the image is
         * copied instead. */
 
        if (image_in_search_path(scope, IMAGE_PORTABLE, NULL, image_path))
                return 0;
 
        r = image_target_path(scope, image_path, flags, &target);
        if (r < 0)
                return log_debug_errno(r, "Failed to generate image symlink path: %m");
 
        (void) mkdir_parents(target, 0755);
 
        if (flags & PORTABLE_MIXED_COPY_LINK) {
                if (scope == RUNTIME_SCOPE_USER) {
                        _cleanup_close_ int userns_fd = nsresource_allocate_userns(
                                        /* vl= */ NULL,
                                        /* name= */ NULL,
                                        NSRESOURCE_UIDS_64K);
                        if (userns_fd < 0)
                                return log_debug_errno(userns_fd, "Failed to allocate user namespace: %m");
 
                        _cleanup_close_ int fd = open(image_path, O_DIRECTORY|O_CLOEXEC);
                        if (fd < 0)
                                return log_debug_errno(errno, "Failed to open '%s': %m", image_path);
 
                        struct stat st;
                        if (fstat(fd, &st) < 0)
                                return log_debug_errno(errno, "Failed to stat '%s': %m", image_path);
 
                        _cleanup_(sd_varlink_unrefp) sd_varlink *mountfsd_link = NULL;
                        r = mountfsd_connect(&mountfsd_link);
                        if (r < 0)
                                return r;
 
                        _cleanup_close_ int tree_fd = -EBADF;
                        if (uid_is_foreign(st.st_uid)) {
                                r = mountfsd_mount_directory_fd(
                                                mountfsd_link,
                                                fd,
                                                userns_fd,
                                                DISSECT_IMAGE_FOREIGN_UID,
                                                &tree_fd);
                                if (r < 0)
                                        return r;
                        } else
                                tree_fd = TAKE_FD(fd);
 
                        _cleanup_close_ int directory_fd = -EBADF;
                        r = mountfsd_make_directory(mountfsd_link, target, MODE_INVALID, /* flags= */ 0, &directory_fd);
                        if (r < 0)
                                return r;
 
                        _cleanup_close_ int copy_fd = -EBADF;
                        r = mountfsd_mount_directory_fd(mountfsd_link, directory_fd, userns_fd, DISSECT_IMAGE_FOREIGN_UID, &copy_fd);
                        if (r < 0)
                                return r;
 
                        r = copy_tree_at_foreign(tree_fd, copy_fd, userns_fd);
                        if (r < 0)
                                return r;
                } else {
                        r = copy_tree(image_path,
                                      target,
                                      UID_INVALID,
                                      GID_INVALID,
                                      COPY_FSYNC | COPY_FSYNC_FULL | COPY_SYNCFS,
                                      /* denylist= */ NULL,
                                      /* subvolumes= */ NULL);
                        if (r < 0)
                                return log_debug_errno(
                                                r,
                                                "Failed to copy %s %s %s: %m",
                                                image_path,
                                                glyph(GLYPH_ARROW_RIGHT),
                                                target);
                }
        } else {
                if (symlink(image_path, target) < 0)
                        return log_debug_errno(
                                        errno,
                                        "Failed to link %s %s %s: %m",
                                        image_path,
                                        glyph(GLYPH_ARROW_RIGHT),
                                        target);
        }
 
        (void) portable_changes_add(
                        changes,
                        n_changes,
                        (flags & PORTABLE_MIXED_COPY_LINK) ? PORTABLE_COPY : PORTABLE_SYMLINK,
                        target,
                        image_path);
        return 0;
}
 
static int install_image_and_extensions(
                RuntimeScope scope,
                const Image *image,
                OrderedHashmap *extension_images,
                PortableFlags flags,
                PortableChange **changes,
                size_t *n_changes) {
 
        Image *ext;
        int r;
 
        assert(image);
 
        ORDERED_HASHMAP_FOREACH(ext, extension_images) {
                r = install_image(scope, ext->path, flags, changes, n_changes);
                if (r < 0)
                        return r;
        }
 
        r = install_image(scope, image->path, flags, changes, n_changes);
        if (r < 0)
                return r;
 
        return 0;
}
 
static bool prefix_matches_compatible(char **matches, char **valid_prefixes) {
        /* Checks if all 'matches' are included in the list of 'valid_prefixes' */
 
        STRV_FOREACH(m, matches)
                if (!strv_contains(valid_prefixes, *m))
                        return false;
 
        return true;
}
 
static void log_portable_verb(
                const char *verb,
                const char *message_id,
                const char *image_path,
                const char *profile,
                OrderedHashmap *extension_images,
                char **extension_image_paths,
                PortableFlags flags) {
 
        _cleanup_free_ char *root_base_name = NULL, *extensions_joined = NULL;
        _cleanup_strv_free_ char **extension_base_names = NULL;
        Image *ext;
        int r;
 
        assert(verb);
        assert(message_id);
        assert(image_path);
        assert(!extension_images || !extension_image_paths);
 
        /* Use the same structured metadata as it is attached to units via LogExtraFields=. The main image
         * is logged as PORTABLE_ROOT= and extensions, if any, as individual PORTABLE_EXTENSION= fields. */
 
        r = path_extract_filename(image_path, &root_base_name);
        if (r < 0)
                log_debug_errno(r, "Failed to extract basename from '%s', ignoring: %m", image_path);
 
        ORDERED_HASHMAP_FOREACH(ext, extension_images) {
                _cleanup_free_ char *extension_base_name = NULL;
 
                r = path_extract_filename(ext->path, &extension_base_name);
                if (r < 0) {
                        log_debug_errno(r, "Failed to extract basename from '%s', ignoring: %m", ext->path);
                        continue;
                }
 
                r = strv_extendf(&extension_base_names, "PORTABLE_EXTENSION=%s", extension_base_name);
                if (r < 0)
                        log_oom_debug();
 
                if (!strextend_with_separator(&extensions_joined, ", ", ext->path))
                        log_oom_debug();