HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/shared/dissect-image.c

242,096 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 9280a90974918216809a09219e8a3162bddcf789

Lines 5001–5731 of 5,731

                        r = dissected_image_load_verity_sig_partition(dissected_image, loop_device->fd, verity);
                        if (r < 0)
                                return r;
 
                        r = dissected_image_guess_verity_roothash(dissected_image, verity);
                        if (r < 0)
                                return r;
 
                        r = dissected_image_decrypt(
                                        dissected_image,
                                        /* root= */ NULL,
                                        /* passphrase= */ NULL,
                                        verity,
                                        image_policy,
                                        dissect_image_flags);
                        if (r < 0)
                                return log_debug_errno(r, "Failed to decrypt dissected image: %m");
                } else {
                        userns_fd = namespace_open_by_type(NAMESPACE_USER);
                        if (userns_fd < 0)
                                return log_debug_errno(userns_fd, "Failed to open our own user namespace: %m");
 
                        r = mountfsd_mount_image(
                                        /* vl= */ NULL,
                                        src_fd >= 0 ? FORMAT_PROC_FD_PATH(src_fd) : src,
                                        userns_fd,
                                        options,
                                        image_policy,
                                        verity,
                                        dissect_image_flags,
                                        &dissected_image);
                        if (r < 0)
                                return r;
                }
        }
 
        if (dest) {
                r = mkdir_p_label(dest, 0755);
                if (r < 0)
                        return log_debug_errno(r, "Failed to create destination directory %s: %m", dest);
                r = umount_recursive(dest, 0);
                if (r < 0)
                        return log_debug_errno(r, "Failed to umount under destination directory %s: %m", dest);
        }
 
        r = dissected_image_mount(
                        dissected_image,
                        dest,
                        /* uid_shift= */ UID_INVALID,
                        /* uid_range= */ UID_INVALID,
                        userns_fd,
                        dissect_image_flags);
        if (r < 0)
                return log_debug_errno(r, "Failed to mount image: %m");
 
        if (loop_device) {
                r = loop_device_flock(loop_device, LOCK_UN);
                if (r < 0)
                        return log_debug_errno(r, "Failed to unlock loopback device: %m");
        }
 
        /* If we got os-release values from the caller, then we need to match them with the image's
         * extension-release.d/ content. Return -EINVAL if there's any mismatch.
         * First, check the distro ID. If that matches, then check the new SYSEXT_LEVEL value if
         * available, or else fallback to VERSION_ID. If neither is present (eg: rolling release),
         * then a simple match on the ID will be performed. Also if an extension class was specified,
         * check that it matches or return ENOCSI (which looks like error-no-class if one squints enough). */
        if ((extension_release_data && extension_release_data->os_release_id) || required_class >= 0) {
                _cleanup_strv_free_ char **extension_release = NULL;
                ImageClass class = IMAGE_SYSEXT;
 
                r = load_extension_release_pairs(dest, required_class >= 0 ? required_class : IMAGE_SYSEXT, dissected_image->image_name, relax_extension_release_check, &extension_release);
                if (r == -ENOENT) {
                        if (required_class >= 0)
                                return log_debug_errno(SYNTHETIC_ERRNO(ENOCSI), "Image %s extension-release metadata does not match the expected class", dissected_image->image_name);
 
                        r = load_extension_release_pairs(dest, IMAGE_CONFEXT, dissected_image->image_name, relax_extension_release_check, &extension_release);
                        if (r >= 0)
                                class = IMAGE_CONFEXT;
                }
                if (r < 0)
                        return log_debug_errno(r, "Failed to parse image %s extension-release metadata: %m", dissected_image->image_name);
 
                if (extension_release_data && !isempty(extension_release_data->os_release_id)) {
                        r = extension_release_validate(
                                        dissected_image->image_name,
                                        extension_release_data->os_release_id,
                                        extension_release_data->os_release_id_like,
                                        extension_release_data->os_release_version_id,
                                        class == IMAGE_SYSEXT ? extension_release_data->os_release_sysext_level : extension_release_data->os_release_confext_level,
                                        extension_release_data->os_release_extension_scope,
                                        extension_release,
                                        class);
                        if (r == 0)
                                return log_debug_errno(SYNTHETIC_ERRNO(ESTALE), "Image %s extension-release metadata does not match the root's", dissected_image->image_name);
                        if (r < 0)
                                return log_debug_errno(r, "Failed to compare image %s extension-release metadata with the root's os-release: %m", dissected_image->image_name);
                }
        }
 
        r = dissected_image_relinquish(dissected_image);
        if (r < 0)
                return log_debug_errno(r, "Failed to relinquish dissected image: %m");
 
        if (ret_image)
                *ret_image = TAKE_PTR(dissected_image);
 
        return 0;
}
 
void extension_release_data_done(ExtensionReleaseData *data) {
        assert(data);
 
        data->os_release_id = mfree(data->os_release_id);
        data->os_release_id_like = mfree(data->os_release_id_like);
        data->os_release_version_id = mfree(data->os_release_version_id);
        data->os_release_sysext_level = mfree(data->os_release_sysext_level);
        data->os_release_confext_level = mfree(data->os_release_confext_level);
        data->os_release_extension_scope = mfree(data->os_release_extension_scope);
}
 
int get_common_dissect_directory(char **ret) {
        _cleanup_free_ char *t = NULL;
        int r;
 
        /* A common location we mount dissected images to. The assumption is that everyone who uses this
         * function runs in their own private mount namespace (with mount propagation off on /run/systemd/,
         * and thus can mount something here without affecting anyone else). */
 
        t = strdup("/run/systemd/dissect-root");
        if (!t)
                return log_oom_debug();
 
        r = mkdir_parents(t, 0755);
        if (r < 0)
                return log_debug_errno(r, "Failed to create parent dirs of mount point '%s': %m", t);
 
        r = RET_NERRNO(mkdir(t, 0000)); /* It's supposed to be overmounted, hence let's make this inaccessible */
        if (r < 0 && r != -EEXIST)
                return log_debug_errno(r, "Failed to create mount point '%s': %m", t);
 
        if (ret)
                *ret = TAKE_PTR(t);
 
        return 0;
}
 
#if HAVE_BLKID
 
static JSON_DISPATCH_ENUM_DEFINE(dispatch_architecture, Architecture, architecture_from_string);
static JSON_DISPATCH_ENUM_DEFINE(dispatch_partition_designator, PartitionDesignator, partition_designator_from_string);
 
typedef struct PartitionFields {
        PartitionDesignator designator;
        bool rw;
        bool growfs;
        unsigned partno;
        Architecture architecture;
        sd_id128_t uuid;
        char *fstype;
        char *label;
        uint64_t size;
        uint64_t offset;
        unsigned fsmount_fd_idx;
} PartitionFields;
 
static void partition_fields_done(PartitionFields *f) {
        assert(f);
 
        f->fstype = mfree(f->fstype);
        f->label = mfree(f->label);
}
 
typedef struct MountImageReplyParameters {
        sd_json_variant *partitions;
        bool single_file_system;
        char *image_policy;
        uint64_t image_size;
        uint32_t sector_size;
        sd_id128_t image_uuid;
} MountImageReplyParameters;
 
static void mount_image_reply_parameters_done(MountImageReplyParameters *p) {
        assert(p);
 
        p->image_policy = mfree(p->image_policy);
        p->partitions = sd_json_variant_unref(p->partitions);
}
 
#endif
 
int mountfsd_connect(sd_varlink **ret) {
        int r;
 
        assert(ret);
 
        _cleanup_(sd_varlink_unrefp) sd_varlink *vl = NULL;
        r = sd_varlink_connect_address(&vl, "/run/systemd/io.systemd.MountFileSystem");
        if (r < 0)
                return log_debug_errno(r, "Failed to connect to mountfsd: %m");
 
        r = sd_varlink_set_allow_fd_passing_input(vl, true);
        if (r < 0)
                return log_debug_errno(r, "Failed to enable varlink fd passing for read: %m");
 
        r = sd_varlink_set_allow_fd_passing_output(vl, true);
        if (r < 0)
                return log_debug_errno(r, "Failed to enable varlink fd passing for write: %m");
 
        *ret = TAKE_PTR(vl);
        return 0;
}
 
int mountfsd_mount_image_fd(
                sd_varlink *vl,
                int image_fd,
                int userns_fd,
                const MountOptions *options,
                const ImagePolicy *image_policy,
                const VeritySettings *verity,
                DissectImageFlags flags,
                DissectedImage **ret) {
 
#if HAVE_BLKID
        _cleanup_(mount_image_reply_parameters_done) MountImageReplyParameters p = {};
 
        static const sd_json_dispatch_field dispatch_table[] = {
                { "partitions",         SD_JSON_VARIANT_ARRAY,         sd_json_dispatch_variant, offsetof(struct MountImageReplyParameters, partitions),         SD_JSON_MANDATORY },
                { "singleFileSystem",   SD_JSON_VARIANT_BOOLEAN,       sd_json_dispatch_stdbool, offsetof(struct MountImageReplyParameters, single_file_system), 0                 },
                { "imagePolicy",        SD_JSON_VARIANT_STRING,        sd_json_dispatch_string,  offsetof(struct MountImageReplyParameters, image_policy),       0                 },
                { "imageSize",          _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64,  offsetof(struct MountImageReplyParameters, image_size),         SD_JSON_MANDATORY },
                { "sectorSize",         _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint32,  offsetof(struct MountImageReplyParameters, sector_size),        SD_JSON_MANDATORY },
                { "imageUuid",          SD_JSON_VARIANT_STRING,        sd_json_dispatch_id128,   offsetof(struct MountImageReplyParameters, image_uuid),         0                 },
                {}
        };
 
        _cleanup_(dissected_image_unrefp) DissectedImage *di = NULL;
        _cleanup_close_ int verity_data_fd = -EBADF;
        _cleanup_free_ char *ps = NULL;
        const char *error_id;
        int r;
 
        assert(image_fd >= 0);
        assert(ret);
 
        _cleanup_(sd_varlink_unrefp) sd_varlink *_vl = NULL;
        if (!vl) {
                r = mountfsd_connect(&_vl);
                if (r < 0)
                        return r;
 
                vl = _vl;
        }
 
        _cleanup_close_ int reopened_fd = -EBADF;
 
        image_fd = fd_reopen_condition(image_fd, O_CLOEXEC|O_NOCTTY|O_NONBLOCK|(FLAGS_SET(flags, DISSECT_IMAGE_MOUNT_READ_ONLY) ? O_RDONLY : O_RDWR), O_PATH, &reopened_fd);
        if (image_fd < 0)
                return log_debug_errno(image_fd, "Failed to reopen fd: %m");
 
        r = sd_varlink_push_dup_fd(vl, image_fd);
        if (r < 0)
                return log_debug_errno(r, "Failed to push image fd into varlink connection: %m");
 
        if (userns_fd >= 0) {
                r = sd_varlink_push_dup_fd(vl, userns_fd);
                if (r < 0)
                        return log_debug_errno(r, "Failed to push image fd into varlink connection: %m");
        }
 
        if (image_policy) {
                r = image_policy_to_string(image_policy, /* simplify= */ false, &ps);
                if (r < 0)
                        return log_debug_errno(r, "Failed to format image policy to string: %m");
        }
 
        if (verity && verity->data_path) {
                verity_data_fd = open(verity->data_path, O_RDONLY|O_CLOEXEC);
                if (verity_data_fd < 0)
                        return log_debug_errno(errno, "Failed to open verity data file '%s': %m", verity->data_path);
 
                r = sd_varlink_push_dup_fd(vl, verity_data_fd);
                if (r < 0)
                        return log_debug_errno(r, "Failed to push verity data fd into varlink connection: %m");
        }
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *mount_options = NULL;
        for (PartitionDesignator i = 0; i < _PARTITION_DESIGNATOR_MAX; i++) {
                _cleanup_free_ char *filtered = NULL;
 
                const char *o = mount_options_from_designator(options, i);
                if (!o)
                        continue;
 
                /* We communicate relaxExtensionReleaseCheck separately via the varlink API, so filter it out
                 * from the mount options we pass to mountfsd. */
                if (IN_SET(i, PARTITION_ROOT, PARTITION_USR)) {
                        r = fstab_filter_options(
                                        o,
                                        "x-systemd.relax-extension-release-check\0",
                                        /* ret_namefound= */ NULL,
                                        /* ret_value= */ NULL,
                                        /* ret_values= */ NULL,
                                        &filtered);
                        if (r < 0)
                                return log_debug_errno(r, "Failed to filter mount options: %m");
 
                        if (isempty(filtered))
                                continue;
                }
 
                r = sd_json_variant_merge_objectbo(
                                &mount_options,
                                SD_JSON_BUILD_PAIR_STRING(partition_designator_to_string(i), filtered ?: o));
                if (r < 0)
                        return log_debug_errno(r, "Failed to build mount options array: %m");
        }
 
        sd_json_variant *reply = NULL;
        r = varlink_callbo_and_log(
                        vl,
                        "io.systemd.MountFileSystem.MountImage",
                        &reply,
                        &error_id,
                        SD_JSON_BUILD_PAIR_UNSIGNED("imageFileDescriptor", 0),
                        SD_JSON_BUILD_PAIR_CONDITION(userns_fd >= 0, "userNamespaceFileDescriptor", SD_JSON_BUILD_UNSIGNED(1)),
                        SD_JSON_BUILD_PAIR_BOOLEAN("readOnly", FLAGS_SET(flags, DISSECT_IMAGE_MOUNT_READ_ONLY)),
                        SD_JSON_BUILD_PAIR_BOOLEAN("growFileSystems", FLAGS_SET(flags, DISSECT_IMAGE_GROWFS)),
                        SD_JSON_BUILD_PAIR_CONDITION(!!ps, "imagePolicy", SD_JSON_BUILD_STRING(ps)),
                        JSON_BUILD_PAIR_VARIANT_NON_NULL("mountOptions", mount_options),
                        SD_JSON_BUILD_PAIR_BOOLEAN("relaxExtensionReleaseChecks", mount_options_relax_extension_release_checks(options)),
                        SD_JSON_BUILD_PAIR_BOOLEAN("veritySharing", FLAGS_SET(flags, DISSECT_IMAGE_VERITY_SHARE)),
                        SD_JSON_BUILD_PAIR_CONDITION(verity_data_fd >= 0, "verityDataFileDescriptor", SD_JSON_BUILD_UNSIGNED(userns_fd >= 0 ? 2 : 1)),
                        SD_JSON_BUILD_PAIR_CONDITION(verity && iovec_is_set(&verity->root_hash), "verityRootHash", JSON_BUILD_IOVEC_HEX(&verity->root_hash)),
                        SD_JSON_BUILD_PAIR_CONDITION(verity && iovec_is_set(&verity->root_hash_sig), "verityRootHashSignature", JSON_BUILD_IOVEC_BASE64(&verity->root_hash_sig)),
                        SD_JSON_BUILD_PAIR_BOOLEAN("allowInteractiveAuthentication", FLAGS_SET(flags, DISSECT_IMAGE_ALLOW_INTERACTIVE_AUTH)));
        if (r < 0)
                return r;
 
        r = sd_json_dispatch(reply, dispatch_table, SD_JSON_ALLOW_EXTENSIONS, &p);
        if (r < 0)
                return log_debug_errno(r, "Failed to parse MountImage() reply: %m");
 
        log_debug("Effective image policy: %s", p.image_policy);
 
        sd_json_variant *i;
        JSON_VARIANT_ARRAY_FOREACH(i, p.partitions) {
                _cleanup_close_ int fsmount_fd = -EBADF;
 
                _cleanup_(partition_fields_done) PartitionFields pp = {
                        .designator = _PARTITION_DESIGNATOR_INVALID,
                        .architecture = _ARCHITECTURE_INVALID,
                        .size = UINT64_MAX,
                        .offset = UINT64_MAX,
                        .fsmount_fd_idx = UINT_MAX,
                };
 
                static const sd_json_dispatch_field partition_dispatch_table[] = {
                        { "designator",          SD_JSON_VARIANT_STRING,        dispatch_partition_designator, offsetof(struct PartitionFields, designator),       SD_JSON_MANDATORY },
                        { "writable",            SD_JSON_VARIANT_BOOLEAN,       sd_json_dispatch_stdbool,      offsetof(struct PartitionFields, rw),               SD_JSON_MANDATORY },
                        { "growFileSystem",      SD_JSON_VARIANT_BOOLEAN,       sd_json_dispatch_stdbool,      offsetof(struct PartitionFields, growfs),           SD_JSON_MANDATORY },
                        { "partitionNumber",     _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint,         offsetof(struct PartitionFields, partno),           0                 },
                        { "architecture",        SD_JSON_VARIANT_STRING,        dispatch_architecture,         offsetof(struct PartitionFields, architecture),     0                 },
                        { "partitionUuid",       SD_JSON_VARIANT_STRING,        sd_json_dispatch_id128,        offsetof(struct PartitionFields, uuid),             0                 },
                        { "fileSystemType",      SD_JSON_VARIANT_STRING,        sd_json_dispatch_string,       offsetof(struct PartitionFields, fstype),           SD_JSON_MANDATORY },
                        { "partitionLabel",      SD_JSON_VARIANT_STRING,        sd_json_dispatch_string,       offsetof(struct PartitionFields, label),            0                 },
                        { "size",                _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64,       offsetof(struct PartitionFields, size),             SD_JSON_MANDATORY },
                        { "offset",              _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64,       offsetof(struct PartitionFields, offset),           SD_JSON_MANDATORY },
                        { "mountFileDescriptor", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint,         offsetof(struct PartitionFields, fsmount_fd_idx),   SD_JSON_MANDATORY },
                        {}
                };
 
                r = sd_json_dispatch(i, partition_dispatch_table, SD_JSON_ALLOW_EXTENSIONS, &pp);
                if (r < 0)
                        return log_debug_errno(r, "Failed to parse partition data: %m");
 
                if (pp.fsmount_fd_idx != UINT_MAX) {
                        fsmount_fd = sd_varlink_take_fd(vl, pp.fsmount_fd_idx);
                        if (fsmount_fd < 0)
                                return fsmount_fd;
                }
 
                assert(pp.designator >= 0);
 
                if (!di) {
                        r = dissected_image_new(/* path= */ NULL, &di);
                        if (r < 0)
                                return log_debug_errno(r, "Failed to allocated new dissected image structure: %m");
                }
 
                if (di->partitions[pp.designator].found)
                        return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG), "Duplicate partition data for '%s'.", partition_designator_to_string(pp.designator));
 
                di->partitions[pp.designator] = (DissectedPartition) {
                        .found = true,
                        .rw = pp.rw,
                        .growfs = pp.growfs,
                        .partno = pp.partno,
                        .architecture = pp.architecture,
                        .uuid = pp.uuid,
                        .fstype = TAKE_PTR(pp.fstype),
                        .label = TAKE_PTR(pp.label),
                        .mount_node_fd = -EBADF,
                        .size = pp.size,
                        .offset = pp.offset,
                        .fsmount_fd = TAKE_FD(fsmount_fd),
                };
        }
 
        if (!di)
                return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG), "Partition list is empty.");
 
        di->single_file_system = p.single_file_system;
        di->image_size = p.image_size;
        di->sector_size = p.sector_size;
        di->image_uuid = p.image_uuid;
 
        *ret = TAKE_PTR(di);
        return 0;
#else
        return -EOPNOTSUPP;
#endif
}
 
int mountfsd_mount_image(
                sd_varlink *vl,
                const char *path,
                int userns_fd,
                const MountOptions *options,
                const ImagePolicy *image_policy,
                const VeritySettings *verity,
                DissectImageFlags flags,
                DissectedImage **ret) {
 
        int r;
 
        assert(path);
        assert(ret);
 
        _cleanup_close_ int image_fd = open(path, O_RDONLY|O_CLOEXEC);
        if (image_fd < 0)
                return log_debug_errno(errno, "Failed to open '%s': %m", path);
 
        _cleanup_(dissected_image_unrefp) DissectedImage *di = NULL;
        r = mountfsd_mount_image_fd(vl, image_fd, userns_fd, options, image_policy, verity, flags, &di);
        if (r < 0)
                return r;
 
        if (!di->image_name) {
                r = dissected_image_name_from_path(path, &di->image_name);
                if (r < 0)
                        return r;
        }
 
        *ret = TAKE_PTR(di);
        return 0;
}
 
int mountfsd_mount_directory_fd(
                sd_varlink *vl,
                int directory_fd,
                int userns_fd,
                DissectImageFlags flags,
                int *ret_mount_fd) {
 
        int r;
 
        assert(directory_fd >= 0);
        assert(ret_mount_fd);
 
        /* Pick one identity, not both, that makes no sense. */
        assert(!FLAGS_SET(flags, DISSECT_IMAGE_FOREIGN_UID|DISSECT_IMAGE_IDENTITY_UID));
 
        _cleanup_(sd_varlink_unrefp) sd_varlink *_vl = NULL;
        if (!vl) {
                r = mountfsd_connect(&_vl);
                if (r < 0)
                        return r;
 
                vl = _vl;
        }
 
        r = sd_varlink_push_dup_fd(vl, directory_fd);
        if (r < 0)
                return log_debug_errno(r, "Failed to push directory fd into varlink connection: %m");
 
        if (userns_fd >= 0) {
                r = sd_varlink_push_dup_fd(vl, userns_fd);
                if (r < 0)
                        return log_debug_errno(r, "Failed to push user namespace fd into varlink connection: %m");
        }
 
        sd_json_variant *reply = NULL;
        const char *error_id = NULL;
        r = varlink_callbo_and_log(
                        vl,
                        "io.systemd.MountFileSystem.MountDirectory",
                        &reply,
                        &error_id,
                        SD_JSON_BUILD_PAIR_UNSIGNED("directoryFileDescriptor", 0),
                        SD_JSON_BUILD_PAIR_CONDITION(userns_fd >= 0, "userNamespaceFileDescriptor", SD_JSON_BUILD_UNSIGNED(1)),
                        SD_JSON_BUILD_PAIR_BOOLEAN("readOnly", FLAGS_SET(flags, DISSECT_IMAGE_MOUNT_READ_ONLY)),
                        SD_JSON_BUILD_PAIR_STRING("mode", FLAGS_SET(flags, DISSECT_IMAGE_FOREIGN_UID) ? "foreign" :
                                                          FLAGS_SET(flags, DISSECT_IMAGE_IDENTITY_UID) ? "identity" : "auto"),
                        SD_JSON_BUILD_PAIR_BOOLEAN("allowInteractiveAuthentication", FLAGS_SET(flags, DISSECT_IMAGE_ALLOW_INTERACTIVE_AUTH)));
        if (r < 0)
                return r;
 
        static const sd_json_dispatch_field dispatch_table[] = {
                { "mountFileDescriptor", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint, 0, SD_JSON_MANDATORY },
                {}
        };
 
        unsigned fsmount_fd_idx = UINT_MAX;
        r = sd_json_dispatch(reply, dispatch_table, SD_JSON_ALLOW_EXTENSIONS, &fsmount_fd_idx);
        if (r < 0)
                return log_debug_errno(r, "Failed to parse MountImage() reply: %m");
 
        _cleanup_close_ int fsmount_fd = sd_varlink_take_fd(vl, fsmount_fd_idx);
        if (fsmount_fd < 0)
                return log_debug_errno(fsmount_fd, "Failed to take mount fd from Varlink connection: %m");
 
        *ret_mount_fd = TAKE_FD(fsmount_fd);
        return 0;
}
 
int mountfsd_mount_directory(
                sd_varlink *vl,
                const char *path,
                int userns_fd,
                DissectImageFlags flags,
                int *ret_mount_fd) {
 
        assert(path);
        assert(ret_mount_fd);
 
        _cleanup_close_ int directory_fd = open(path, O_DIRECTORY|O_RDONLY|O_CLOEXEC|O_PATH);
        if (directory_fd < 0)
                return log_debug_errno(errno, "Failed to open '%s': %m", path);
 
        return mountfsd_mount_directory_fd(vl, directory_fd, userns_fd, flags, ret_mount_fd);
}
 
int mountfsd_make_directory_fd(
                sd_varlink *vl,
                int parent_fd,
                const char *name,
                mode_t mode,
                DissectImageFlags flags,
                int *ret_directory_fd) {
 
        int r;
 
        assert(parent_fd >= 0);
        assert(name);
 
        _cleanup_(sd_varlink_unrefp) sd_varlink *_vl = NULL;
        if (!vl) {
                r = mountfsd_connect(&_vl);
                if (r < 0)
                        return r;
 
                vl = _vl;
        }
 
        r = sd_varlink_push_dup_fd(vl, parent_fd);
        if (r < 0)
                return log_debug_errno(r, "Failed to push parent fd into varlink connection: %m");
 
        sd_json_variant *reply = NULL;
        const char *error_id = NULL;
        r = varlink_callbo_and_log(
                        vl,
                        "io.systemd.MountFileSystem.MakeDirectory",
                        &reply,
                        &error_id,
                        SD_JSON_BUILD_PAIR_UNSIGNED("parentFileDescriptor", 0),
                        SD_JSON_BUILD_PAIR_STRING("name", name),
                        SD_JSON_BUILD_PAIR_CONDITION(!IN_SET(mode, MODE_INVALID, 0700), "mode", SD_JSON_BUILD_UNSIGNED(mode)), /* suppress this field if default/unset */
                        SD_JSON_BUILD_PAIR_BOOLEAN("allowInteractiveAuthentication", FLAGS_SET(flags, DISSECT_IMAGE_ALLOW_INTERACTIVE_AUTH)));
        if (r < 0)
                return r;
 
        static const sd_json_dispatch_field dispatch_table[] = {
                { "directoryFileDescriptor", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint, 0, SD_JSON_MANDATORY },
                {}
        };
 
        unsigned directory_fd_idx = UINT_MAX;
        r = sd_json_dispatch(reply, dispatch_table, SD_JSON_ALLOW_EXTENSIONS, &directory_fd_idx);
        if (r < 0)
                return log_debug_errno(r, "Failed to parse MountImage() reply: %m");
 
        _cleanup_close_ int directory_fd = sd_varlink_take_fd(vl, directory_fd_idx);
        if (directory_fd < 0)
                return log_debug_errno(directory_fd, "Failed to take directory fd from Varlink connection: %m");
 
        if (ret_directory_fd)
                *ret_directory_fd = TAKE_FD(directory_fd);
        return 0;
}
 
int mountfsd_make_directory(
                sd_varlink *vl,
                const char *path,
                mode_t mode,
                DissectImageFlags flags,
                int *ret_directory_fd) {
 
        int r;
 
        _cleanup_free_ char *parent = NULL;
        r = path_extract_directory(path, &parent);
        if (r < 0)
                return log_debug_errno(r, "Failed to extract parent directory from '%s': %m", path);
 
        _cleanup_free_ char *dirname = NULL;
        r = path_extract_filename(path, &dirname);
        if (r < 0)
                return log_debug_errno(r, "Failed to extract directory name from '%s': %m", path);
 
        _cleanup_close_ int fd = open(parent, O_DIRECTORY|O_CLOEXEC);
        if (fd < 0)
                return log_debug_errno(errno, "Failed to open '%s': %m", parent);
 
        return mountfsd_make_directory_fd(vl, fd, dirname, mode, flags, ret_directory_fd);
}
 
int copy_tree_at_foreign(int source_fd, int target_fd, int userns_fd) {
        int r;
 
        assert(source_fd >= 0);
        assert(target_fd >= 0);
        assert(userns_fd >= 0);
 
        /* Copies dir referenced by source_fd into dir referenced by source_fd, moves to the specified userns
         * for that, which should be foreign UID range */
 
        r = pidref_safe_fork_full(
                        "copy-tree",
                        /* stdio_fds= */ NULL,
                        (int[]) { userns_fd, source_fd, target_fd }, 3,
                        FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_DEATHSIG_SIGTERM|FORK_WAIT|FORK_REOPEN_LOG,
                        /* ret= */ NULL);
        if (r < 0)
                return r;
        if (r == 0) {
                r = namespace_enter(
                                /* pidns_fd= */ -EBADF,
                                /* mntns_fd= */ -EBADF,
                                /* netns_fd= */ -EBADF,
                                userns_fd,
                                /* root_fd= */ -EBADF);
                if (r < 0) {
                        log_debug_errno(r, "Failed to join user namespace: %m");
                        _exit(EXIT_FAILURE);
                }
 
                r = copy_tree_at(
                                source_fd, /* from= */ NULL,
                                target_fd, /* to= */ NULL,
                                /* override_uid= */ UID_INVALID,
                                /* override_gid= */ GID_INVALID,
                                COPY_HARDLINKS|COPY_MERGE_EMPTY|COPY_MERGE_APPLY_STAT|COPY_SAME_MOUNT|COPY_ALL_XATTRS,
                                /* denylist= */ NULL,
                                /* subvolumes= */ NULL);
                if (r < 0) {
                        log_debug_errno(r, "Failed to copy tree: %m");
                        _exit(EXIT_FAILURE);
                }
 
                _exit(EXIT_SUCCESS);
        }
 
        return 0;
}
 
int remove_tree_foreign(const char *path, int userns_fd) {
        int r;
 
        assert(path);
        assert(userns_fd >= 0);
 
        _cleanup_close_ int tree_fd = -EBADF;
        r = mountfsd_mount_directory(
                        /* vl= */ NULL,
                        path,
                        userns_fd,
                        DISSECT_IMAGE_FOREIGN_UID,
                        &tree_fd);
        if (r < 0)
                return r;
 
        r = pidref_safe_fork_full(
                        "rm-tree",
                        /* stdio_fds= */ NULL,
                        (int[]) { userns_fd, tree_fd }, 2,
                        FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_DEATHSIG_SIGTERM|FORK_WAIT|FORK_REOPEN_LOG,
                        /* ret= */ NULL);
        if (r < 0)
                return r;
        if (r == 0) {
                /* child */
 
                r = namespace_enter(
                                /* pidns_fd= */ -EBADF,
                                /* mntns_fd= */ -EBADF,
                                /* netns_fd= */ -EBADF,
                                userns_fd,
                                /* root_fd= */ -EBADF);
                if (r < 0) {
                        log_debug_errno(r, "Failed to join user namespace: %m");
                        _exit(EXIT_FAILURE);
                }
 
                _cleanup_close_ int dfd = fd_reopen(tree_fd, O_DIRECTORY|O_CLOEXEC);
                if (dfd < 0) {
                        log_debug_errno(dfd, "Failed to reopen tree fd: %m");
                        _exit(EXIT_FAILURE);
                }
 
                r = rm_rf_children(dfd, REMOVE_PHYSICAL|REMOVE_SUBVOLUME|REMOVE_CHMOD, /* root_dev= */ NULL);
                if (r < 0)
                        log_debug_errno(r, "Failed to empty '%s' directory in foreign UID mode, ignoring: %m", path);
 
                _exit(EXIT_SUCCESS);
        }
 
        return 0;
}