HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/portable/portable.c
Git blob: 0d42a3c41aa6ccdbda76b016df825fad2759375e
Lines 1–1000 of 2,720
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <linux/loop.h>
#include <sched.h>
#include <unistd.h>
#include "sd-bus.h"
#include "sd-messages.h"
#include "sd-varlink.h"
#include "bus-common-errors.h"
#include "bus-error.h"
#include "bus-locator.h"
#include "chase.h"
#include "conf-files.h"
#include "copy.h"
#include "cryptsetup-util.h"
#include "data-fd-util.h"
#include "dirent-util.h"
#include "discover-image.h"
#include "dissect-image.h"
#include "env-file.h"
#include "env-util.h"
#include "errno-util.h"
#include "escape.h"
#include "extension-util.h"
#include "extract-word.h"
#include "fd-util.h"
#include "fileio.h"
#include "fs-util.h"
#include "glyph-util.h"
#include "image-policy.h"
#include "install.h"
#include "iovec-util.h"
#include "libmount-util.h"
#include "log-context.h"
#include "log.h"
#include "loop-util.h"
#include "mkdir.h"
#include "namespace-util.h"
#include "nsresource.h"
#include "os-util.h"
#include "path-lookup.h"
#include "path-util.h"
#include "pidref.h"
#include "portable.h"
#include "portable-util.h"
#include "process-util.h"
#include "rm-rf.h"
#include "selinux-util.h"
#include "set.h"
#include "socket-util.h"
#include "sort-util.h"
#include "string-table.h"
#include "strv.h"
#include "tmpfile-util.h"
#include "uid-classification.h"
#include "unit-name.h"
#include "vpick.h"
/* Markers used in the first line of our 20-portable.conf unit file drop-in to determine, that a) the unit file was
* dropped there by the portable service logic and b) for which image it was dropped there. */
#define PORTABLE_DROPIN_MARKER_BEGIN "# Drop-in created for image '"
#define PORTABLE_DROPIN_MARKER_END "', do not edit."
static bool prefix_match(const char *unit, const char *prefix) {
const char *p;
p = startswith(unit, prefix);
if (!p)
return false;
/* Only respect prefixes followed by dash or dot or when there's a complete match */
return IN_SET(*p, '-', '.', '@', 0);
}
static bool unit_match(const char *unit, char **matches) {
const char *dot;
dot = strrchr(unit, '.');
if (!dot)
return false;
if (!STR_IN_SET(dot, ".service", ".socket", ".target", ".timer", ".path"))
return false;
/* Empty match expression means: everything */
if (strv_isempty(matches))
return true;
/* Otherwise, at least one needs to match */
STRV_FOREACH(i, matches)
if (prefix_match(unit, *i))
return true;
return false;
}
static PortableMetadata *portable_metadata_new(const char *name, const char *path, const char *selinux_label, int fd) {
PortableMetadata *m;
m = malloc0(offsetof(PortableMetadata, name) + strlen(name) + 1);
if (!m)
return NULL;
/* In case of a layered attach, we want to remember which image the unit came from */
if (path) {
m->image_path = strdup(path);
if (!m->image_path)
return mfree(m);
}
/* The metadata file might have SELinux labels, we need to carry them and reapply them */
if (!isempty(selinux_label)) {
m->selinux_label = strdup(selinux_label);
if (!m->selinux_label) {
free(m->image_path);
return mfree(m);
}
}
strcpy(m->name, name);
m->fd = fd;
return TAKE_PTR(m);
}
PortableMetadata *portable_metadata_unref(PortableMetadata *i) {
if (!i)
return NULL;
safe_close(i->fd);
free(i->source);
free(i->image_path);
free(i->selinux_label);
return mfree(i);
}
static int compare_metadata(PortableMetadata *const *x, PortableMetadata *const *y) {
assert(x);
assert(y);
return strcmp((*x)->name, (*y)->name);
}
int portable_metadata_hashmap_to_sorted_array(Hashmap *unit_files, PortableMetadata ***ret) {
_cleanup_free_ PortableMetadata **sorted = NULL;
PortableMetadata *item;
size_t k = 0;
assert(ret);
sorted = new(PortableMetadata*, hashmap_size(unit_files));
if (!sorted)
return -ENOMEM;
HASHMAP_FOREACH(item, unit_files)
sorted[k++] = item;
assert(k == hashmap_size(unit_files));
typesafe_qsort(sorted, k, compare_metadata);
*ret = TAKE_PTR(sorted);
return 0;
}
static int send_one_fd_iov_with_data_fd(
int socket_fd,
const struct iovec *iov,
size_t iovlen,
int fd) {
_cleanup_close_ int data_fd = -EBADF;
assert(iov || iovlen == 0);
assert(socket_fd >= 0);
assert(fd >= 0);
data_fd = copy_data_fd(fd);
if (data_fd < 0)
return data_fd;
return send_one_fd_iov(socket_fd, data_fd, iov, iovlen, 0);
}
DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(portable_metadata_hash_ops, char, string_hash_func, string_compare_func,
PortableMetadata, portable_metadata_unref);
static int receive_portable_metadata(
int socket_fd,
const char *path,
PortableMetadata **ret_os_release,
Hashmap **ret_unit_files) {
_cleanup_(portable_metadata_unrefp) PortableMetadata* os_release = NULL;
_cleanup_(hashmap_freep) Hashmap *unit_files = NULL;
int r;
assert(socket_fd >= 0);
assert(path);
assert(ret_os_release);
assert(ret_unit_files);
unit_files = hashmap_new(&portable_metadata_hash_ops);
if (!unit_files)
return -ENOMEM;
for (;;) {
_cleanup_(portable_metadata_unrefp) PortableMetadata *add = NULL;
_cleanup_close_ int fd = -EBADF;
/* We use NAME_MAX space for the SELinux label here. The kernel currently enforces no limit,
* but according to suggestions from the SELinux people this will change and it will probably
* be identical to NAME_MAX. For now we use that, but this should be updated one day when the
* final limit is known. */
char iov_buffer[PATH_MAX + NAME_MAX + 2 + 1]; /* One extra byte for the trailing NUL we add below. */
struct iovec iov = IOVEC_MAKE(iov_buffer, sizeof(iov_buffer) - 1);
ssize_t n = receive_one_fd_iov(socket_fd, &iov, 1, 0, &fd);
if (n == -EIO)
break;
if (n < 0)
return log_debug_errno(n, "Failed to receive item: %m");
iov_buffer[n] = 0;
/* We can't really distinguish a zero-length datagram without any fds from EOF (both are
* signalled the same way by recvmsg()). Hence, accept either as end notification. */
if (isempty(iov_buffer) && fd < 0)
break;
if (isempty(iov_buffer) || fd < 0)
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
"Invalid item sent from child.");
/* Given recvmsg cannot be used with multiple io vectors if you don't know the size in
* advance, use a marker to separate the name and the optional SELinux context. */
char *selinux_label = memchr(iov_buffer, 0, n);
assert(selinux_label);
selinux_label++;
add = portable_metadata_new(iov_buffer, path, selinux_label, fd);
if (!add)
return -ENOMEM;
fd = -EBADF;
/* Note that we do not initialize 'add->source' here, as the source path is not usable here
* as it refers to a path only valid in the short-living namespaced child process we forked
* here. */
if (PORTABLE_METADATA_IS_UNIT(add)) {
r = hashmap_put(unit_files, add->name, add);
if (r < 0)
return log_debug_errno(r, "Failed to add item to unit file list: %m");
add = NULL;
} else if (PORTABLE_METADATA_IS_OS_RELEASE(add) || PORTABLE_METADATA_IS_EXTENSION_RELEASE(add)) {
assert(!os_release);
os_release = TAKE_PTR(add);
} else
assert_not_reached();
}
*ret_os_release = TAKE_PTR(os_release);
*ret_unit_files = TAKE_PTR(unit_files);
return 0;
}
static int extract_now(
RuntimeScope scope,
int rfd,
const char *image_path,
char **matches,
const char *image_name,
bool path_is_extension,
bool relax_extension_release_check,
int socket_fd,
PortableMetadata **ret_os_release,
Hashmap **ret_unit_files) {
_cleanup_hashmap_free_ Hashmap *unit_files = NULL;
_cleanup_(portable_metadata_unrefp) PortableMetadata *os_release = NULL;
_cleanup_(lookup_paths_done) LookupPaths paths = {};
_cleanup_close_ int os_release_fd = -EBADF;
_cleanup_free_ char *os_release_path = NULL;
const char *os_release_id;
int r;
/* Extracts the metadata from a directory tree 'dir_fd'. Extracts two kinds of information: the /etc/os-release
* data, and all unit files matching the specified expression. Note that this function is called in two very
* different but also similar contexts. When the tool gets invoked on a directory tree, we'll process it
* directly, and in-process, and thus can return the requested data directly, via 'ret_os_release' and
* 'ret_unit_files'. However, if the tool is invoked on a raw disk image — which needs to be mounted first — we
* are invoked in a child process with private mounts and then need to send the collected data to our
* parent. To handle both cases in one call this function also gets a 'socket_fd' parameter, which when >= 0 is
* used to send the data to the parent. */
assert(scope < _RUNTIME_SCOPE_MAX);
assert(rfd >= 0);
/* First, find os-release/extension-release and send it upstream (or just save it). */
if (path_is_extension) {
ImageClass class = IMAGE_SYSEXT;
r = open_extension_release_at(rfd, IMAGE_SYSEXT, image_name, relax_extension_release_check, &os_release_path, &os_release_fd);
if (r == -ENOENT) {
r = open_extension_release_at(rfd, IMAGE_CONFEXT, image_name, relax_extension_release_check, &os_release_path, &os_release_fd);
if (r >= 0)
class = IMAGE_CONFEXT;
}
if (r < 0)
return log_error_errno(r, "Failed to open extension release from '%s': %m", image_name);
os_release_id = strjoina((class == IMAGE_SYSEXT) ? "/usr/lib" : "/etc", "/extension-release.d/extension-release.", image_name);
} else {
os_release_id = "/etc/os-release";
r = open_os_release_at(rfd, &os_release_path, &os_release_fd);
}
if (r < 0)
log_debug_errno(r,
"Couldn't acquire %s file, ignoring: %m",
path_is_extension ? "extension-release " : "os-release");
else {
if (socket_fd >= 0) {
struct iovec iov[] = {
IOVEC_MAKE_STRING(os_release_id),
IOVEC_MAKE((char *)"\0", sizeof(char)),
};
r = send_one_fd_iov_with_data_fd(socket_fd, iov, ELEMENTSOF(iov), os_release_fd);
if (r < 0)
return log_debug_errno(r, "Failed to send os-release file: %m");
}
if (ret_os_release) {
os_release = portable_metadata_new(os_release_id, NULL, NULL, os_release_fd);
if (!os_release)
return -ENOMEM;
os_release_fd = -EBADF;
os_release->source = TAKE_PTR(os_release_path);
}
}
/* Then, send unit file data to the parent (or/and add it to the hashmap). For that we use our usual
* unit discovery logic. If we're running in a user session, we look for units in
* /usr/lib/systemd/user/ and corresponding directories. */
r = lookup_paths_init(
&paths,
scope == RUNTIME_SCOPE_USER ? RUNTIME_SCOPE_GLOBAL : RUNTIME_SCOPE_SYSTEM,
LOOKUP_PATHS_SPLIT_USR,
/* root_dir= */ NULL);
if (r < 0)
return log_debug_errno(r, "Failed to acquire lookup paths: %m");
unit_files = hashmap_new(&portable_metadata_hash_ops);
if (!unit_files)
return -ENOMEM;
STRV_FOREACH(i, paths.search_path) {
_cleanup_free_ char *relative = NULL, *resolved = NULL;
_cleanup_closedir_ DIR *d = NULL;
r = chase_and_opendirat(rfd, rfd, *i, /* chase_flags= */ 0, &relative, &d);
if (r < 0) {
log_debug_errno(r, "Failed to open unit path '%s', ignoring: %m", *i);
continue;
}
r = chaseat_prefix_root(relative, image_path, &resolved);
if (r < 0)
return r;
FOREACH_DIRENT(de, d, return log_debug_errno(errno, "Failed to read directory: %m")) {
_cleanup_(portable_metadata_unrefp) PortableMetadata *m = NULL;
_cleanup_freecon_ char *con = NULL;
_cleanup_close_ int fd = -EBADF;
struct stat st;
if (!unit_name_is_valid(de->d_name, UNIT_NAME_ANY))
continue;
if (!unit_match(de->d_name, matches))
continue;
/* Filter out duplicates */
if (hashmap_contains(unit_files, de->d_name))
continue;
if (!IN_SET(de->d_type, DT_LNK, DT_REG))
continue;
fd = chase_and_openat(
rfd,
dirfd(d),
de->d_name,
CHASE_MUST_BE_REGULAR,
O_RDONLY|O_CLOEXEC,
/* ret_path= */ NULL);
if (fd < 0) {
log_debug_errno(fd, "Failed to open unit file '%s', ignoring: %m", de->d_name);
continue;
}
/* Reject empty files, just in case */
if (fstat(fd, &st) < 0) {
log_debug_errno(errno, "Failed to stat unit file '%s', ignoring: %m", de->d_name);
continue;
}
if (st.st_size <= 0) {
log_debug("Unit file '%s' is empty, ignoring.", de->d_name);
continue;
}
#if HAVE_SELINUX
/* The units will be copied on the host's filesystem, so if they had a SELinux label
* we have to preserve it. Copy it out so that it can be applied later. */
if (mac_selinux_use()) {
r = sym_fgetfilecon_raw(fd, &con);
if (r < 0 && !ERRNO_IS_XATTR_ABSENT(errno))
log_debug_errno(errno, "Failed to get SELinux file context from '%s', ignoring: %m", de->d_name);
}
#endif
if (socket_fd >= 0) {
struct iovec iov[] = {
IOVEC_MAKE_STRING(de->d_name),
IOVEC_MAKE((char *)"\0", sizeof(char)),
IOVEC_MAKE_STRING(strempty(con)),
};
r = send_one_fd_iov_with_data_fd(socket_fd, iov, ELEMENTSOF(iov), fd);
if (r < 0)
return log_debug_errno(r, "Failed to send unit metadata to parent: %m");
}
m = portable_metadata_new(de->d_name, image_path, con, fd);
if (!m)
return -ENOMEM;
fd = -EBADF;
m->source = path_join(resolved, de->d_name);
if (!m->source)
return -ENOMEM;
r = hashmap_put(unit_files, m->name, m);
if (r < 0)
return log_debug_errno(r, "Failed to add unit to hashmap: %m");
m = NULL;
}
}
if (ret_os_release)
*ret_os_release = TAKE_PTR(os_release);
if (ret_unit_files)
*ret_unit_files = TAKE_PTR(unit_files);
return 0;
}
static int portable_extract_by_path(
RuntimeScope scope,
const char *path,
bool path_is_extension,
bool relax_extension_release_check,
char **matches,
const ImagePolicy *image_policy,
PortableMetadata **ret_os_release,
Hashmap **ret_unit_files,
ImagePolicy **ret_pinned_image_policy,
sd_bus_error *error) {
_cleanup_hashmap_free_ Hashmap *unit_files = NULL;
_cleanup_(portable_metadata_unrefp) PortableMetadata* os_release = NULL;
_cleanup_(image_policy_freep) ImagePolicy *pinned_image_policy = NULL;
int r;
assert(path);
_cleanup_close_ int rfd = open(path, O_PATH|O_CLOEXEC);
if (rfd < 0)
return log_debug_errno(errno, "Failed to open '%s': %m", path);
struct stat st;
if (fstat(rfd, &st) < 0)
return log_debug_errno(errno, "Failed to stat '%s': %m", path);
if (S_ISDIR(st.st_mode)) {
_cleanup_free_ char *image_name = NULL;
r = path_extract_filename(path, &image_name);
if (r < 0)
return log_debug_errno(r, "Failed to extract image name from path '%s': %m", path);
if (scope == RUNTIME_SCOPE_USER && uid_is_foreign(st.st_uid)) {
_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 mfd = -EBADF;
r = mountfsd_mount_directory_fd(
/* vl= */ NULL,
rfd,
userns_fd,
DISSECT_IMAGE_FOREIGN_UID,
&mfd);
if (r < 0)
return r;
_cleanup_close_pair_ int seq[2] = EBADF_PAIR;
if (socketpair(AF_UNIX, SOCK_SEQPACKET|SOCK_CLOEXEC, 0, seq) < 0)
return log_debug_errno(errno, "Failed to allocated SOCK_SEQPACKET socket: %m");
_cleanup_close_pair_ int errno_pipe_fd[2] = EBADF_PAIR;
if (pipe2(errno_pipe_fd, O_CLOEXEC|O_NONBLOCK) < 0)
return log_debug_errno(errno, "Failed to create pipe: %m");
_cleanup_(pidref_done_sigkill_wait) PidRef child = PIDREF_NULL;
r = pidref_safe_fork("(sd-extract)",
FORK_RESET_SIGNALS|FORK_DEATHSIG_SIGKILL|FORK_REOPEN_LOG,
&child);
if (r < 0)
return r;
if (r == 0) {
seq[0] = safe_close(seq[0]);
errno_pipe_fd[0] = safe_close(errno_pipe_fd[0]);
if (setns(userns_fd, CLONE_NEWUSER) < 0) {
r = log_debug_errno(errno, "Failed to join userns: %m");
report_errno_and_exit(errno_pipe_fd[1], r);
}
r = extract_now(scope,
mfd,
path,
matches,
image_name,
path_is_extension,
relax_extension_release_check,
seq[1],
/* ret_os_release= */ NULL,
/* ret_unit_files= */ NULL);
report_errno_and_exit(errno_pipe_fd[1], r);
}
seq[1] = safe_close(seq[1]);
errno_pipe_fd[1] = safe_close(errno_pipe_fd[1]);
r = receive_portable_metadata(seq[0], path, &os_release, &unit_files);
if (r < 0)
return r;
r = pidref_wait_for_terminate_and_check("(sd-extract)", &child, 0);
if (r < 0)
return r;
if (r != EXIT_SUCCESS) {
if (read(errno_pipe_fd[0], &r, sizeof(r)) == sizeof(r))
return log_debug_errno(r, "Failed to extract portable metadata from '%s': %m", path);
return log_debug_errno(SYNTHETIC_ERRNO(EPROTO), "Child failed.");
}
} else {
r = extract_now(scope,
rfd,
path,
matches,
image_name,
path_is_extension,
relax_extension_release_check,
/* socket_fd= */ -EBADF,
&os_release,
&unit_files);
if (r < 0)
return r;
}
} else {
_cleanup_(dissected_image_unrefp) DissectedImage *m = NULL;
_cleanup_(rmdir_and_freep) char *tmpdir = NULL;
_cleanup_close_pair_ int seq[2] = EBADF_PAIR, errno_pipe_fd[2] = EBADF_PAIR;
_cleanup_(pidref_done_sigkill_wait) PidRef child = PIDREF_NULL;
_cleanup_close_ int userns_fd = -EBADF;
DissectImageFlags flags =
DISSECT_IMAGE_READ_ONLY |
DISSECT_IMAGE_GENERIC_ROOT |
DISSECT_IMAGE_REQUIRE_ROOT |
DISSECT_IMAGE_DISCARD_ON_LOOP |
DISSECT_IMAGE_RELAX_VAR_CHECK |
DISSECT_IMAGE_USR_NO_ROOT |
DISSECT_IMAGE_ADD_PARTITION_DEVICES |
DISSECT_IMAGE_PIN_PARTITION_DEVICES |
DISSECT_IMAGE_VERITY_SHARE |
DISSECT_IMAGE_ALLOW_USERSPACE_VERITY;
if (path_is_extension)
flags |= DISSECT_IMAGE_VALIDATE_OS_EXT | (relax_extension_release_check ? DISSECT_IMAGE_RELAX_EXTENSION_CHECK : 0);
else
flags |= DISSECT_IMAGE_VALIDATE_OS;
_cleanup_(verity_settings_done) VeritySettings verity = VERITY_SETTINGS_DEFAULT;
r = verity_settings_load(
&verity,
path,
/* root_hash_path= */ NULL,
/* root_hash_sig_path= */ NULL);
if (r < 0)
return log_debug_errno(r, "Failed to read verity artifacts for %s: %m", path);
if (verity.data_path)
flags |= DISSECT_IMAGE_NO_PARTITION_TABLE;
/* We now have a loopback block device, let's fork off a child in its own mount namespace, mount it
* there, and extract the metadata we need. The metadata is sent from the child back to us. */
/* Load some libraries before we fork workers off that want to use them */
(void) dlopen_cryptsetup(LOG_DEBUG);
(void) dlopen_libmount(LOG_DEBUG);
r = mkdtemp_malloc("/tmp/inspect-XXXXXX", &tmpdir);
if (r < 0)
return log_debug_errno(r, "Failed to create temporary directory: %m");
if (scope == RUNTIME_SCOPE_USER) {
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");
r = mountfsd_mount_image_fd(
/* vl= */ NULL,
rfd,
userns_fd,
/* options= */ NULL,
image_policy,
&verity,
flags,
&m);
if (r < 0)
return r;
} else {
_cleanup_(loop_device_unrefp) LoopDevice *d = NULL;
r = loop_device_make_by_path_at(
rfd,
/* path= */ NULL,
O_RDONLY,
/* sector_size= */ UINT32_MAX,
LO_FLAGS_PARTSCAN,
LOCK_SH,
&d);
if (r < 0)
return log_debug_errno(r, "Failed to set up loopback device for %s: %m", path);
r = dissect_loop_device(
d,
&verity,
/* mount_options= */ NULL,
image_policy,
/* image_filter= */ NULL,
flags,
&m);
if (r == -ENOPKG)
sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Couldn't identify a suitable partition table or file system in '%s'.", path);
else if (r == -EADDRNOTAVAIL)
sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "No root partition for specified root hash found in '%s'.", path);
else if (r == -ENOTUNIQ)
sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Multiple suitable root partitions found in image '%s'.", path);
else if (r == -ENXIO)
sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "No suitable root partition found in image '%s'.", path);
else if (r == -EPROTONOSUPPORT)
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);
if (r < 0)
return r;
r = dissected_image_load_verity_sig_partition(m, d->fd, &verity);
if (r < 0)
return log_debug_errno(r, "Failed to load verity sig partition for '%s': %m", path);
r = dissected_image_guess_verity_roothash(m, &verity);
if (r < 0)
return log_debug_errno(r, "Failed to guess verity roothash for '%s': %m", path);
}
if (!m->image_name) {
r = dissected_image_name_from_path(path, &m->image_name);
if (r < 0)
return r;
}
if (ret_pinned_image_policy) {
pinned_image_policy = image_policy_new_from_dissected(m, &verity);
if (!pinned_image_policy)
return -ENOMEM;
}
if (socketpair(AF_UNIX, SOCK_SEQPACKET|SOCK_CLOEXEC, 0, seq) < 0)
return log_debug_errno(errno, "Failed to allocated SOCK_SEQPACKET socket: %m");
if (pipe2(errno_pipe_fd, O_CLOEXEC|O_NONBLOCK) < 0)
return log_debug_errno(errno, "Failed to create pipe: %m");
r = pidref_safe_fork(
"(sd-dissect)",
FORK_RESET_SIGNALS|FORK_DEATHSIG_SIGKILL|(scope == RUNTIME_SCOPE_SYSTEM ? FORK_NEW_MOUNTNS|FORK_MOUNTNS_SLAVE : 0),
&child);
if (r < 0)
return r;
if (r == 0) {
seq[0] = safe_close(seq[0]);
errno_pipe_fd[0] = safe_close(errno_pipe_fd[0]);
if (scope == RUNTIME_SCOPE_USER) {
r = detach_mount_namespace_userns(userns_fd);
if (r < 0) {
log_debug_errno(r, "Failed to detach mount namespace: %m");
report_errno_and_exit(errno_pipe_fd[1], r);
}
}
r = dissected_image_mount(
m,
tmpdir,
/* uid_shift= */ UID_INVALID,
/* uid_range= */ UID_INVALID,
userns_fd,
flags);
if (r < 0) {
log_debug_errno(r, "Failed to mount dissected image '%s': %m", path);
report_errno_and_exit(errno_pipe_fd[1], r);
}
_cleanup_close_ int mfd = open(tmpdir, O_DIRECTORY|O_CLOEXEC);
if (mfd < 0) {
r = log_debug_errno(errno, "Failed to open '%s': %m", tmpdir);
report_errno_and_exit(errno_pipe_fd[1], r);
}
r = extract_now(scope,
mfd,
path,
matches,
m->image_name,
path_is_extension,
relax_extension_release_check,
seq[1],
/* ret_os_release= */ NULL,
/* ret_unit_files= */ NULL);
report_errno_and_exit(errno_pipe_fd[1], r);
}
seq[1] = safe_close(seq[1]);
errno_pipe_fd[1] = safe_close(errno_pipe_fd[1]);
r = receive_portable_metadata(seq[0], path, &os_release, &unit_files);
if (r < 0)
return r;
r = pidref_wait_for_terminate_and_check("(sd-dissect)", &child, 0);
if (r < 0)
return r;
pidref_done(&child);
if (r != EXIT_SUCCESS) {
if (read(errno_pipe_fd[0], &r, sizeof(r)) == sizeof(r))
return log_debug_errno(r, "Failed to extract portable metadata from '%s': %m", path);
return log_debug_errno(SYNTHETIC_ERRNO(EPROTO), "Child failed.");
}
}
if (!os_release)
return sd_bus_error_setf(error,
SD_BUS_ERROR_INVALID_ARGS,
"Image '%s' lacks %s data, refusing.",
path,
path_is_extension ? "extension-release" : "os-release");
if (ret_unit_files)
*ret_unit_files = TAKE_PTR(unit_files);
if (ret_os_release)
*ret_os_release = TAKE_PTR(os_release);
if (ret_pinned_image_policy)
*ret_pinned_image_policy = TAKE_PTR(pinned_image_policy);
return 0;
}
static int extract_image_and_extensions(
RuntimeScope scope,
const char *name_or_path,
char **matches,
char **extension_image_paths,
bool validate_extension,
bool relax_extension_release_check,
const ImagePolicy *image_policy,
Image **ret_image,
OrderedHashmap **ret_extension_images,
OrderedHashmap **ret_extension_releases,
PortableMetadata **ret_os_release,
Hashmap **ret_unit_files,
char ***ret_valid_prefixes,
ImagePolicy **ret_pinned_root_image_policy,
ImagePolicy **ret_pinned_ext_image_policy,
sd_bus_error *error) {
_cleanup_free_ char *id = NULL, *id_like = NULL, *version_id = NULL, *sysext_level = NULL, *confext_level = NULL;
_cleanup_(image_policy_freep) ImagePolicy *pinned_root_image_policy = NULL, *pinned_ext_image_policy = NULL;
_cleanup_(portable_metadata_unrefp) PortableMetadata *os_release = NULL;
_cleanup_ordered_hashmap_free_ OrderedHashmap *extension_images = NULL, *extension_releases = NULL;
_cleanup_(pick_result_done) PickResult result = PICK_RESULT_NULL;
_cleanup_hashmap_free_ Hashmap *unit_files = NULL;
_cleanup_strv_free_ char **valid_prefixes = NULL;
_cleanup_(image_unrefp) Image *image = NULL;
Image *ext;
int r;
assert(name_or_path);
/* If we get a path, then check if it can be resolved with vpick. We need this as we might just
* get a simple image name, which would make vpick error out. */
if (path_is_absolute(name_or_path)) {
r = path_pick(/* root_path= */ NULL,
/* root_fd= */ AT_FDCWD,
/* dir_fd= */ AT_FDCWD,
name_or_path,
pick_filter_image_any,
ELEMENTSOF(pick_filter_image_any),
PICK_ARCHITECTURE|PICK_TRIES|PICK_RESOLVE,
&result);
if (r < 0)
return r;
if (!result.path)
return log_debug_errno(
SYNTHETIC_ERRNO(ENOENT),
"No matching entry in .v/ directory %s found.",
name_or_path);
name_or_path = result.path;
}
r = image_find_harder(scope, IMAGE_PORTABLE, name_or_path, /* root= */ NULL, &image);
if (r < 0)
return r;
if (!strv_isempty(extension_image_paths)) {
extension_images = ordered_hashmap_new(&image_hash_ops);
if (!extension_images)
return -ENOMEM;
if (ret_extension_releases) {
extension_releases = ordered_hashmap_new(&portable_metadata_hash_ops);
if (!extension_releases)
return -ENOMEM;
}
STRV_FOREACH(p, extension_image_paths) {
_cleanup_(pick_result_done) PickResult ext_result = PICK_RESULT_NULL;
_cleanup_(image_unrefp) Image *new = NULL;
const char *path = *p;
if (path_is_absolute(*p)) {
r = path_pick(/* root_path= */ NULL,
/* root_fd= */ AT_FDCWD,
/* dir_fd= */ AT_FDCWD,
*p,
pick_filter_image_any,
ELEMENTSOF(pick_filter_image_any),
PICK_ARCHITECTURE|PICK_TRIES|PICK_RESOLVE,
&ext_result);
if (r < 0)
return r;
if (!ext_result.path)
return log_debug_errno(
SYNTHETIC_ERRNO(ENOENT),
"No matching entry in .v/ directory %s found.",
*p);
path = ext_result.path;
}
r = image_find_harder(scope, IMAGE_PORTABLE, path, NULL, &new);
if (r < 0)
return r;
r = ordered_hashmap_put(extension_images, new->name, new);
if (r < 0)
return r;
TAKE_PTR(new);
}
}
r = portable_extract_by_path(
scope,
image->path,
/* path_is_extension= */ false,
/* relax_extension_release_check= */ false,
matches,
image_policy,
&os_release,
&unit_files,
&pinned_root_image_policy,
error);
if (r < 0)
return r;
/* If we are layering extension images on top of a runtime image, check that the os-release and
* extension-release metadata match, otherwise reject it immediately as invalid, or it will fail when
* the units are started. Also, collect valid portable prefixes if caller requested that. */
if (validate_extension || ret_valid_prefixes) {
_cleanup_free_ char *prefixes = NULL, *portable_scope_str = NULL;
r = parse_env_file_fd(
os_release->fd, os_release->name,
"ID", &id,
"ID_LIKE", &id_like,
"VERSION_ID", &version_id,
"SYSEXT_LEVEL", &sysext_level,
"CONFEXT_LEVEL", &confext_level,
"PORTABLE_PREFIXES", &prefixes,
"PORTABLE_SCOPE", &portable_scope_str);
if (r < 0)
return r;
if (isempty(id))
return sd_bus_error_set_errnof(error, ESTALE, "Image %s os-release metadata lacks the ID field", name_or_path);
if (prefixes) {
valid_prefixes = strv_split(prefixes, WHITESPACE);
if (!valid_prefixes)
return -ENOMEM;
}
RuntimeScope portable_scope = RUNTIME_SCOPE_SYSTEM;
if (portable_scope_str) {
if (streq(portable_scope_str, "any"))
portable_scope = _RUNTIME_SCOPE_INVALID;
else {
portable_scope = runtime_scope_from_string(portable_scope_str);
if (portable_scope < 0)
return sd_bus_error_setf(
error,
SD_BUS_ERROR_INVALID_ARGS,
"Invalid PORTABLE_SCOPE value '%s' in image %s.",
portable_scope_str,
name_or_path);
}
}
if (portable_scope != _RUNTIME_SCOPE_INVALID && portable_scope != scope)
return sd_bus_error_setf(
error,
SD_BUS_ERROR_INVALID_ARGS,
"Image %s portable scope '%s' incompatible with portabled runtime scope '%s'.",
name_or_path,
runtime_scope_to_string(portable_scope),
runtime_scope_to_string(scope));
}
ORDERED_HASHMAP_FOREACH(ext, extension_images) {
_cleanup_(portable_metadata_unrefp) PortableMetadata *extension_release_meta = NULL;
_cleanup_(image_policy_freep) ImagePolicy *policy = NULL;
_cleanup_hashmap_free_ Hashmap *extra_unit_files = NULL;
_cleanup_strv_free_ char **extension_release = NULL;
const char *e;
r = portable_extract_by_path(
scope,
ext->path,
/* path_is_extension= */ true,
relax_extension_release_check,
matches,
image_policy,
&extension_release_meta,
&extra_unit_files,
&policy,
error);
if (r < 0)
return r;
r = hashmap_move(unit_files, extra_unit_files);
if (r < 0)
return r;
if (!pinned_ext_image_policy && policy)
pinned_ext_image_policy = TAKE_PTR(policy);
else if (policy) {
_cleanup_(image_policy_freep) ImagePolicy *intersected_policy = NULL;
/* There is a single policy for all extension images, so we need a union */
r = image_policy_union(pinned_ext_image_policy, policy, &intersected_policy);
if (r < 0)