HALF ECHO LEARN / REFERENCE COLLECTION
v262.2test/units/TEST-13-NSPAWN.nspawn.sh
Git blob: 8ca8d53230d0de41705f96b06f8c255a8d989b11
Lines 1001–1774 of 1,774
# $LISTEN_PIDFDID must not refer to a different process than $LISTEN_PID
test "${LISTEN_PIDFDID-unset}" = "unset"
else
test "$LISTEN_PID" = "$$"
fi
for ((fd = 3; fd < 3 + LISTEN_FDS; fd++)); do
test -S "/proc/self/fd/$fd"
done
if [[ ! -v EXPECTED_PID ]]; then
# sd_listen_fds() only accepts the fds if both $LISTEN_PID and $LISTEN_PIDFDID refer to the calling
# process. exec keeps both our PID and our pidfd inode ID.
exec /usr/bin/test-fdstore listen exit
fi
EOF
chmod +x "$entrypoint"
nspawn=(systemd-nspawn --register=no --directory="$root")
# Without --as-pid2 the payload is PID 1 in the container...
systemd-socket-activate --listen="$socket1" --fdname=hoge --now -- \
"${nspawn[@]}" --setenv=EXPECTED_FDNAMES=hoge "${entrypoint##"$root"}"
rm -f "$socket1"
# ...and with --as-pid2 it's PID 2, as the stub PID 1 forks it off.
systemd-socket-activate --listen="$socket1" --fdname=hoge --now -- \
"${nspawn[@]}" --as-pid2 --setenv=EXPECTED_FDNAMES=hoge "${entrypoint##"$root"}"
rm -f "$socket1"
# Multiple file descriptors are passed on in order
systemd-socket-activate --listen="$socket1" --listen="$socket2" --fdname=hoge --fdname=fuga --now -- \
"${nspawn[@]}" --as-pid2 --setenv=EXPECTED_FDS=2 --setenv=EXPECTED_FDNAMES=hoge:fuga \
"${entrypoint##"$root"}"
rm -f "$socket1" "$socket2"
# Escape sequences in $LISTEN_FDNAMES are resolved the same way sd_listen_fds_with_names() does, and the
# names are escaped again when passed on, so that the payload ends up with the same names
systemd-socket-activate --listen="$socket1" --listen="$socket2" \
--fdname='ho\ge' --fdname='fu\\ga' --now -- \
"${nspawn[@]}" --as-pid2 --setenv=EXPECTED_FDS=2 --setenv='EXPECTED_FDNAMES=hoge:fu\\ga' \
"${entrypoint##"$root"}"
rm -f "$socket1" "$socket2"
# The prefix nspawn adds to the names of fd store entries it forwards upstream is stripped again, but
# only if nspawn actually forwards fd store entries, i.e. it has an upstream fd store
systemd-socket-activate --listen="$socket1" --fdname=payload-hoge --now -- \
"${nspawn[@]}" --as-pid2 --setenv=EXPECTED_FDNAMES=payload-hoge "${entrypoint##"$root"}"
rm -f "$socket1"
systemd-run --wait --pipe -p Type=notify -p NotifyAccess=all -p FileDescriptorStoreMax=1 -- \
bash -c 'exec systemd-socket-activate -E NOTIFY_SOCKET -E FDSTORE "$@"' _ \
--listen="$socket1" --fdname=payload-hoge --now -- \
"${nspawn[@]}" --keep-unit --as-pid2 --setenv=EXPECTED_FDNAMES=hoge "${entrypoint##"$root"}"
rm -f "$socket1"
# $LISTEN_FDNAMES is not passed on if it is not set, ...
systemd-socket-activate --listen="$socket1" --now -- \
"${nspawn[@]}" --as-pid2 --setenv=EXPECTED_FDNAMES=unset "${entrypoint##"$root"}"
rm -f "$socket1"
# ...doesn't match the number of file descriptors, ...
systemd-socket-activate --listen="$socket1" --fdname=hoge --fdname=fuga --now -- \
"${nspawn[@]}" --as-pid2 --setenv=EXPECTED_FDNAMES=unset "${entrypoint##"$root"}"
rm -f "$socket1"
# ...cannot be parsed, ...
# shellcheck disable=SC1003
systemd-socket-activate --listen="$socket1" --fdname='hoge\' --now -- \
"${nspawn[@]}" --as-pid2 --setenv=EXPECTED_FDNAMES=unset "${entrypoint##"$root"}"
rm -f "$socket1"
# ...or contains invalid names
systemd-socket-activate --listen="$socket1" --fdname=$'ho\tge' --now -- \
"${nspawn[@]}" --as-pid2 --setenv=EXPECTED_FDNAMES=unset "${entrypoint##"$root"}"
rm -f "$socket1"
# An explicit --setenv= takes precedence over the socket activation variables, and $LISTEN_PIDFDID is
# not set if $LISTEN_PID is overridden
systemd-socket-activate --listen="$socket1" --fdname=hoge --now -- \
"${nspawn[@]}" --as-pid2 \
--setenv=LISTEN_FDNAMES=override --setenv=EXPECTED_FDNAMES=override \
--setenv=LISTEN_PID=4711 --setenv=EXPECTED_PID=4711 \
"${entrypoint##"$root"}"
rm -f "$socket1"
rm -fr "$root"
}
testcase_os_release() {
local root entrypoint os_release_source
root="$(mktemp -d /var/lib/machines/TEST-13-NSPAWN.os-release.XXX)"
create_dummy_container "$root"
entrypoint="$root/entrypoint.sh"
cat >"$entrypoint" <<\EOF
#!/usr/bin/env bash
set -ex
. /tmp/os-release
[[ -n "${ID:-}" && "$ID" != "$container_host_id" ]] && exit 1
[[ -n "${VERSION_ID:-}" && "$VERSION_ID" != "$container_host_version_id" ]] && exit 1
[[ -n "${BUILD_ID:-}" && "$BUILD_ID" != "$container_host_build_id" ]] && exit 1
[[ -n "${VARIANT_ID:-}" && "$VARIANT_ID" != "$container_host_variant_id" ]] && exit 1
cd /tmp
(cd /run/host && md5sum os-release) | md5sum -c
EOF
chmod +x "$entrypoint"
os_release_source="/etc/os-release"
if [[ ! -r "$os_release_source" ]]; then
os_release_source="/usr/lib/os-release"
elif [[ -L "$os_release_source" ]]; then
# Ensure that /etc always wins if available
cp --remove-destination -fv /usr/lib/os-release /etc/os-release
echo MARKER=1 >>/etc/os-release
fi
systemd-nspawn --register=no \
--directory="$root" \
--bind="$os_release_source:/tmp/os-release" \
"${entrypoint##"$root"}"
if grep -q MARKER /etc/os-release; then
ln -svrf /usr/lib/os-release /etc/os-release
fi
rm -fr "$root"
}
testcase_machinectl_bind() {
local service_path service_name root container_name ec
local cmd="timeout 10 bash -c 'until [[ -f /tmp/marker ]] && [[ -f /tmp/marker-varlink ]]; do sleep .5; done'; sleep 3"
root="$(mktemp -d /var/lib/machines/TEST-13-NSPAWN.machinectl-bind.XXX)"
create_dummy_container "$root"
container_name="$(basename "$root")"
service_path="$(mktemp /run/systemd/system/nspawn-machinectl-bind-XXX.service)"
service_name="${service_path##*/}"
cat >"$service_path" <<EOF
[Service]
Type=notify
ExecStart=systemd-nspawn --directory="$root" --notify-ready=no bash -xec "$cmd"
EOF
systemctl daemon-reload
systemctl start "$service_name"
touch /tmp/marker
machinectl bind --mkdir "$container_name" /tmp/marker
touch /tmp/marker-varlink
varlinkctl call /run/systemd/machine/io.systemd.Machine io.systemd.Machine.BindMount "{\"name\": \"$container_name\", \"source\": \"/tmp/marker-varlink\", \"mkdir\": true}"
timeout 10 bash -c "while [[ '\$(systemctl show -P SubState $service_name)' == running ]]; do sleep .2; done"
ec="$(systemctl show -P ExecMainStatus "$service_name")"
systemctl stop "$service_name"
rm -fr "$root" "$service_path"
return "$ec"
}
testcase_selinux() {
# Basic test coverage to avoid issues like https://github.com/systemd/systemd/issues/19976
if ! command -v selinuxenabled >/dev/null || ! selinuxenabled; then
echo >&2 "SELinux is not enabled, skipping SELinux-related tests"
return 0
fi
local root
root="$(mktemp -d /var/lib/machines/TEST-13-NSPAWN.selinux.XXX)"
create_dummy_container "$root"
chcon -R -t container_t "$root"
systemd-nspawn --register=no \
--boot \
--directory="$root" \
--selinux-apifs-context=system_u:object_r:container_file_t:s0:c0,c1 \
--selinux-context=system_u:system_r:container_t:s0:c0,c1
rm -fr "$root"
}
testcase_ephemeral_config() {
# https://github.com/systemd/systemd/issues/13297
local root container_name
root="$(mktemp -d /var/lib/machines/TEST-13-NSPAWN.ephemeral-config.XXX)"
create_dummy_container "$root"
container_name="$(basename "$root")"
mkdir -p /run/systemd/nspawn/
rm -f "/etc/systemd/nspawn/$container_name.nspawn"
cat >"/run/systemd/nspawn/$container_name.nspawn" <<EOF
[Files]
${COVERAGE_BUILD_DIR:+"Bind=$COVERAGE_BUILD_DIR"}
BindReadOnly=/tmp/ephemeral-config
EOF
touch /tmp/ephemeral-config
systemd-nspawn --register=no \
--directory="$root" \
--ephemeral \
bash -x -c "test -f /tmp/ephemeral-config"
systemd-nspawn --register=no \
--directory="$root" \
--ephemeral \
--machine=foobar \
bash -x -c "! test -f /tmp/ephemeral-config"
rm -fr "$root" "/run/systemd/nspawn/$container_name.nspawn"
}
matrix_run_one() {
local use_cgns="${1:?}"
local api_vfs_writable="${2:?}"
local root
if [[ "$use_cgns" == "yes" && "$IS_CGNS_SUPPORTED" == "no" ]]; then
echo >&2 "CGroup namespaces are not supported, skipping..."
return 0
fi
root="$(mktemp -d "/var/lib/machines/TEST-13-NSPAWN.cgns-$1-api-vfs-writable-$2.XXX")"
create_dummy_container "$root"
SYSTEMD_NSPAWN_USE_CGNS="$use_cgns" SYSTEMD_NSPAWN_API_VFS_WRITABLE="$api_vfs_writable" \
systemd-nspawn --register=no \
--directory="$root" \
--boot
SYSTEMD_NSPAWN_USE_CGNS="$use_cgns" SYSTEMD_NSPAWN_API_VFS_WRITABLE="$api_vfs_writable" \
systemd-nspawn --register=no \
--directory="$root" \
--private-network \
--boot
if SYSTEMD_NSPAWN_USE_CGNS="$use_cgns" SYSTEMD_NSPAWN_API_VFS_WRITABLE="$api_vfs_writable" \
systemd-nspawn --register=no \
--directory="$root" \
--private-users=pick \
--boot; then
[[ "$IS_USERNS_SUPPORTED" == "yes" && "$api_vfs_writable" == "network" ]] && return 1
else
[[ "$IS_USERNS_SUPPORTED" == "no" && "$api_vfs_writable" == "network" ]] && return 1
fi
if SYSTEMD_NSPAWN_USE_CGNS="$use_cgns" SYSTEMD_NSPAWN_API_VFS_WRITABLE="$api_vfs_writable" \
systemd-nspawn --register=no \
--directory="$root" \
--private-network \
--private-users=pick \
--boot; then
[[ "$IS_USERNS_SUPPORTED" == "yes" && "$api_vfs_writable" == "yes" ]] && return 1
else
[[ "$IS_USERNS_SUPPORTED" == "no" && "$api_vfs_writable" = "yes" ]] && return 1
fi
local netns_opt="--network-namespace-path=/proc/self/ns/net"
local net_opt
local net_opts=(
"--network-bridge=lo"
"--network-interface=lo"
"--network-ipvlan=lo"
"--network-macvlan=lo"
"--network-veth"
"--network-veth-extra=lo"
"--network-zone=zone"
)
# --network-namespace-path and network-related options cannot be used together
for net_opt in "${net_opts[@]}"; do
echo "$netns_opt in combination with $net_opt should fail"
if SYSTEMD_NSPAWN_USE_CGNS="$use_cgns" SYSTEMD_NSPAWN_API_VFS_WRITABLE="$api_vfs_writable" \
systemd-nspawn --register=no \
--directory="$root" \
--boot \
"$netns_opt" \
"$net_opt"; then
echo >&2 "unexpected pass"
return 1
fi
done
# allow combination of --network-namespace-path and --private-network
SYSTEMD_NSPAWN_USE_CGNS="$use_cgns" SYSTEMD_NSPAWN_API_VFS_WRITABLE="$api_vfs_writable" \
systemd-nspawn --register=no \
--directory="$root" \
--boot \
--private-network \
"$netns_opt"
# test --network-namespace-path works with a network namespace created by "ip netns"
ip netns add nspawn_test
netns_opt="--network-namespace-path=/run/netns/nspawn_test"
SYSTEMD_NSPAWN_USE_CGNS="$use_cgns" SYSTEMD_NSPAWN_API_VFS_WRITABLE="$api_vfs_writable" \
systemd-nspawn --register=no \
--directory="$root" \
--network-namespace-path=/run/netns/nspawn_test \
ip a | grep -v -E '^1: lo.*UP'
ip netns del nspawn_test
# test --network-namespace-path works when combined with --private-users=pick
ip netns add nspawn_test
ip netns exec nspawn_test ip link add foo type dummy
if [[ "$IS_USERNS_SUPPORTED" == "yes" && "$api_vfs_writable" == "no" ]]; then
SYSTEMD_NSPAWN_USE_CGNS="$use_cgns" SYSTEMD_NSPAWN_API_VFS_WRITABLE="$api_vfs_writable" \
systemd-nspawn --register=no \
--directory="$root" \
--private-users=pick \
--network-namespace-path=/run/netns/nspawn_test \
ip link show dev foo
fi
ip netns del nspawn_test
rm -fr "$root"
return 0
}
testcase_ping_group_range() {
local range root
if [[ "$IS_USERNS_SUPPORTED" == "no" ]]; then
echo "Skipping user namespace test..."
return 0
fi
root="$(mktemp -d /var/lib/machines/TEST-13-NSPAWN.ping-group-range.XXX)"
create_dummy_container "$root"
trap 'rm -fr "$root"' RETURN ERR
range="$(systemd-nspawn --pipe --register=no \
--directory="$root" \
--private-network \
--private-users=pick \
cat /proc/sys/net/ipv4/ping_group_range)"
assert_eq "${range//[[:space:]]/ }" "0 65535"
}
testcase_api_vfs() {
local api_vfs_writable
for api_vfs_writable in yes no network; do
matrix_run_one no $api_vfs_writable
matrix_run_one yes $api_vfs_writable
done
}
testcase_check_os_release() {
# https://github.com/systemd/systemd/issues/29185
local base common_opts root
base="$(mktemp -d /var/lib/machines/TEST-13-NSPAWN.check_os_release_base.XXX)"
root="$(mktemp -d /var/lib/machines/TEST-13-NSPAWN.check_os_release.XXX)"
create_dummy_container "$base"
cp -d "$base"/{bin,sbin,lib} "$root/"
if [ -d "$base"/lib64 ]; then
cp -d "$base"/lib64 "$root/"
fi
common_opts=(
--boot
--register=no
--directory="$root"
--bind-ro="$base/usr:/usr"
)
# Might be needed to find libraries
if [ -f "$base/etc/ld.so.cache" ]; then
common_opts+=("--bind-ro=$base/etc/ld.so.cache:/etc/ld.so.cache")
fi
# Empty /etc/ & /usr/
(! systemd-nspawn "${common_opts[@]}")
(! SYSTEMD_NSPAWN_CHECK_OS_RELEASE=1 systemd-nspawn "${common_opts[@]}")
(! SYSTEMD_NSPAWN_CHECK_OS_RELEASE=foo systemd-nspawn "${common_opts[@]}")
SYSTEMD_NSPAWN_CHECK_OS_RELEASE=0 systemd-nspawn "${common_opts[@]}"
# Empty /usr/ + a broken /etc/os-release -> /usr/os-release symlink
ln -svrf "$root/etc/os-release" "$root/usr/os-release"
(! systemd-nspawn "${common_opts[@]}")
(! SYSTEMD_NSPAWN_CHECK_OS_RELEASE=1 systemd-nspawn "${common_opts[@]}")
SYSTEMD_NSPAWN_CHECK_OS_RELEASE=0 systemd-nspawn "${common_opts[@]}"
rm -fr "$root" "$base"
}
testcase_ip_masquerade() {
local root
if ! command -v networkctl >/dev/null; then
echo "This test requires systemd-networkd, skipping..."
return 0
fi
systemctl unmask systemd-networkd.service
systemctl edit --runtime --stdin systemd-networkd.service --drop-in=debug.conf <<EOF
[Service]
Environment=SYSTEMD_LOG_LEVEL=debug
EOF
systemctl start systemd-networkd.service
root="$(mktemp -d /var/lib/machines/TEST-13-NSPAWN.ip_masquerade.XXX)"
create_dummy_container "$root"
systemd-run --unit=nspawn-hoge.service \
systemd-nspawn \
--register=no \
--directory="$root" \
--ephemeral \
--machine=hoge \
--network-veth \
bash -x -c "ip link set host0 up; sleep 30s"
/usr/lib/systemd/systemd-networkd-wait-online -i ve-hoge --timeout 30s
# Check IPMasquerade= for ve-* and friends enabled IP forwarding.
[[ "$(cat /proc/sys/net/ipv4/conf/all/forwarding)" == "1" ]]
[[ "$(cat /proc/sys/net/ipv4/conf/default/forwarding)" == "1" ]]
[[ "$(cat /proc/sys/net/ipv6/conf/all/forwarding)" == "1" ]]
[[ "$(cat /proc/sys/net/ipv6/conf/default/forwarding)" == "1" ]]
systemctl stop nspawn-hoge.service || :
systemctl stop systemd-networkd.service
systemctl mask systemd-networkd.service
rm -fr "$root"
}
create_dummy_ddi() {
local outdir="${1:?}"
local container_name="${2:?}"
cat >"$outdir"/openssl.conf <<EOF
[ req ]
prompt = no
distinguished_name = req_distinguished_name
[ req_distinguished_name ]
C = DE
ST = Test State
L = Test Locality
O = Org Name
OU = Org Unit Name
CN = Common Name
emailAddress = test@email.com
EOF
openssl req -config "$outdir"/openssl.conf -subj="/CN=waldo" \
-x509 -sha256 -nodes -days 365 -newkey rsa:4096 \
-keyout "${outdir}/${container_name}.key" -out "${outdir}/${container_name}.crt"
mkdir -p /run/verity.d
cp "${outdir}/${container_name}.crt" "/run/verity.d/test-13-nspawn-${container_name}.crt"
SYSTEMD_REPART_OVERRIDE_FSTYPE=squashfs \
systemd-repart --make-ddi=portable \
--copy-source=/usr/share/TEST-13-NSPAWN-container-template \
--certificate="${outdir}/${container_name}.crt" \
--private-key="${outdir}/${container_name}.key" \
"${outdir}/${container_name}.raw"
}
testcase_unpriv() {
if ! can_do_rootless_nspawn; then
echo "Skipping rootless test..."
return 0
fi
local tmpdir name
tmpdir="$(mktemp -d /var/tmp/TEST-13-NSPAWN.unpriv.XXX)"
# Note: we pick the machine name short enough to be a valid machine name,
# but definitely longer than 16 chars, so that userns name mangling in the
# nsresourced userns allocation logic is triggered and tested. */
name="unprv-${tmpdir##*.}-somelongsuffix"
trap 'rm -fr ${tmpdir@Q} || true; rm -f /run/verity.d/test-13-nspawn-${name@Q} || true' RETURN ERR
create_dummy_ddi "$tmpdir" "$name"
chown --recursive testuser: "$tmpdir"
run0 --pipe -u testuser systemd-run \
--user \
--pipe \
--property=Delegate=yes \
-- \
systemd-nspawn --pipe --private-network --register=no --keep-unit --image="$tmpdir/$name.raw" echo hello >"$tmpdir/stdout.txt"
echo hello | cmp "$tmpdir/stdout.txt" -
# Make sure per-user search path logic works
run0 -u testuser --pipe mkdir -p /home/testuser/.local/state/machines
run0 -u testuser --pipe ln -s "$tmpdir/$name.raw" /home/testuser/.local/state/machines/"x$name.raw"
run0 --pipe -u testuser systemd-run \
--user \
--pipe \
--property=Delegate=yes \
-- \
systemd-nspawn --pipe --private-network --register=no --keep-unit --machine="x$name" echo hello >"$tmpdir/stdout.txt"
echo hello | cmp "$tmpdir/stdout.txt" -
}
testcase_fuse() {
# On some kernels reading from /dev/fuse without an attached connection blocks indefinitely
# rather than returning EPERM, so guard the probe with a short timeout and skip the test
# whenever we don't get the expected error string.
if [[ "$(timeout --foreground 5 cat <>/dev/fuse 2>&1)" != 'cat: -: Operation not permitted' ]]; then
echo "FUSE is not supported, skipping the test..."
return 0
fi
# Assume that the tests are running on a kernel that is new enough for FUSE
# to have user-namespace support; and so we should expect that nspawn
# enables FUSE. This test does not validate that the version check
# disables FUSE on old kernels.
local root
root="$(mktemp -d /var/lib/machines/TEST-13-NSPAWN.fuse.XXX)"
create_dummy_container "$root"
# To avoid adding any complex dependencies to the test, we simply check
# that /dev/fuse can be opened for reading and writing (O_RDWR), but that
# actually reading from it fails with EPERM. This can be done with a
# simple Bash script: run `cat <>/dev/fuse` and if the EPERM error message
# comes from "bash" then we know it couldn't be opened, while if it comes
# from "cat" then we know that it was opened but not read. If we are able
# to read from the file, then this indicates that it's not a real FUSE
# device (which requires us to mount a type="fuse" filesystem with the
# option string "fd=${num}" for /dev/fuse FD before reading from it will
# return anything other than EPERM); if this happens then most likely
# nspawn didn't create the file at all and Bash "<>" simply created a new
# normal file.
#
# "cat: -: Operation not permitted" # pass the test; opened but not read
# "bash: line 1: /dev/fuse: Operation not permitted" # fail the test; could not open
# "" # fail the test; reading worked
[[ "$(timeout --foreground 30 systemd-nspawn --register=no --pipe --directory="$root" \
bash -c 'cat <>/dev/fuse' 2>&1)" == 'cat: -: Operation not permitted' ]]
rm -fr "$root"
}
testcase_unpriv_fuse() {
# Same as above, but for unprivileged operation.
if [[ "$(timeout --foreground 5 cat <>/dev/fuse 2>&1)" != 'cat: -: Operation not permitted' ]]; then
echo "FUSE is not supported, skipping the test..."
return 0
fi
if ! can_do_rootless_nspawn; then
echo "Skipping rootless test..."
return 0
fi
local tmpdir name
tmpdir="$(mktemp -d /var/tmp/TEST-13-NSPAWN.unpriv-fuse.XXX)"
# $name must be such that len("ns-$(id -u testuser)-nspawn-${name}-65535")
# <= 31, or nsresourced will reject the request for a namespace.
# Therefore; len($name) <= 10 bytes.
name="ufuse-${tmpdir##*.}"
trap 'rm -fr ${tmpdir@Q} || true; rm -f /run/verity.d/test-13-nspawn-${name@Q} || true' RETURN ERR
create_dummy_ddi "$tmpdir" "$name"
chown --recursive testuser: "$tmpdir"
[[ "$(timeout --foreground 60 run0 -u testuser --pipe systemd-run \
--user \
--pipe \
--property=Delegate=yes \
--setenv=SYSTEMD_LOG_LEVEL \
--setenv=SYSTEMD_LOG_TARGET \
-- \
systemd-nspawn --pipe --private-network --register=no --keep-unit --image="$tmpdir/$name.raw" \
bash -c 'cat <>/dev/fuse' 2>&1)" == *'cat: -: Operation not permitted' ]]
}
test_tun() {
systemd-nspawn --register=no "$@" bash -xec '[[ -c /dev/net/tun ]]; [[ "$(stat /dev/net/tun --format=%u)" == 0 ]]; [[ "$(stat /dev/net/tun --format=%g)" == 0 ]]'
# check if the owner of the host device is unchanged, see issue #34243.
[[ "$(stat /dev/net/tun --format=%u)" == 0 ]]
[[ "$(stat /dev/net/tun --format=%g)" == 0 ]]
# Without DeviceAllow= for /dev/net/tun, see issue #35116.
systemd-run \
--wait -p Environment=SYSTEMD_LOG_LEVEL=debug -p DevicePolicy=closed -p DeviceAllow="char-pts rw" \
systemd-nspawn --register=no "$@" bash -xec '[[ ! -e /dev/net/tun ]]'
[[ "$(stat /dev/net/tun --format=%u)" == 0 ]]
[[ "$(stat /dev/net/tun --format=%g)" == 0 ]]
}
testcase_dev_net_tun() {
local root
if [[ ! -c /dev/net/tun ]]; then
echo "/dev/net/tun does not exist, skipping tests"
return 0
fi
root="$(mktemp -d /var/lib/machines/TEST-13-NSPAWN.tun.XXX)"
create_dummy_container "$root"
test_tun --ephemeral --directory="$root" --private-users=no
test_tun --ephemeral --directory="$root" --private-users=yes
test_tun --ephemeral --directory="$root" --private-users=pick
test_tun --ephemeral --directory="$root" --private-users=no --private-network
test_tun --ephemeral --directory="$root" --private-users=yes --private-network
test_tun --ephemeral --directory="$root" --private-users=pick --private-network
rm -fr "$root"
}
testcase_unpriv_dir() {
if ! can_do_rootless_nspawn; then
echo "Skipping rootless test..."
return 0
fi
root="$(mktemp -d /var/lib/machines/TEST-13-NSPAWN.unpriv.XXX)"
create_dummy_container "$root"
assert_eq "$(systemd-nspawn --pipe --register=no -D "$root" --private-users=no bash -c 'echo foobar')" "foobar"
# Use an image owned by some freshly acquired container user
assert_eq "$(systemd-nspawn --pipe --register=no -D "$root" --private-users=pick --private-users-ownership=chown bash -c 'echo foobar')" "foobar"
assert_eq "$(systemd-nspawn --pipe --register=no -D "$root" --private-users=yes --private-users-ownership=chown bash -c 'echo foobar')" "foobar"
# Now move back to root owned, and try to use fs idmapping
systemd-dissect --shift "$root" 0
assert_eq "$(systemd-nspawn --pipe --register=no -D "$root" --private-users=no --private-users-ownership=no bash -c 'echo foobar')" "foobar"
assert_eq "$(systemd-nspawn --pipe --register=no -D "$root" --private-users=pick --private-users-ownership=map bash -c 'echo foobar')" "foobar"
# Use an image owned by the foreign UID range first via direct mapping, and than via the managed uid logic
systemd-dissect --shift "$root" foreign
assert_eq "$(systemd-nspawn --pipe --register=no -D "$root" --private-users=pick --private-users-ownership=foreign bash -c 'echo foobar')" "foobar"
assert_eq "$(systemd-nspawn --pipe --register=no -D "$root" --private-users=managed --private-network bash -c 'echo foobar')" "foobar"
# Test unprivileged operation
chown testuser:testuser "$root/.."
ls -al "/var/lib/machines"
ls -al "$root"
assert_eq "$(run0 --pipe -u testuser systemd-nspawn --pipe --register=no -D "$root" --private-users=managed --private-network bash -c 'echo foobar')" "foobar"
assert_eq "$(run0 --pipe -u testuser systemd-nspawn --pipe --register=no -D "$root" --private-network bash -c 'echo foobar')" "foobar"
chown root:root "$root/.."
rm -rf "$root"
}
testcase_link_journal_host() {
local root hoge i
root="$(mktemp -d /var/lib/machines/TEST-13-NSPAWN.link-journal.XXX)"
create_dummy_container "$root"
systemd-id128 new >"$root"/etc/machine-id
hoge="/var/log/journal/$(cat "$root"/etc/machine-id)/"
mkdir -p "$hoge"
# The systemd-journal group is not mapped, so ensure the directory is owned by root:root
chown root:root "$hoge"
for i in no yes pick; do
systemd-nspawn \
--register=no --directory="$root" --private-users="$i" --link-journal=host \
bash -xec 'p="/var/log/journal/$(cat /etc/machine-id)"; mountpoint "$p"; [[ "$(stat "$p" --format=%u)" == 0 ]]; touch "$p/hoge"'
[[ "$(stat "${hoge}/hoge" --format=%u)" == 0 ]]
rm "${hoge}/hoge"
done
rm -fr "$root" "$hoge"
}
testcase_volatile_link_journal_no_userns() {
local root machine_id journal_dir acl_output
root="$(mktemp -d /var/lib/machines/TEST-13-NSPAWN.volatile-journal.XXX)"
create_dummy_container "$root"
machine_id="$(systemd-id128 new)"
echo "$machine_id" >"$root/etc/machine-id"
journal_dir="/var/log/journal/$machine_id"
mkdir -p "$journal_dir"
chown root:root "$journal_dir"
systemd-nspawn --register=no \
--directory="$root" \
--boot \
--volatile=yes \
--link-journal=host \
systemd.unit=systemd-tmpfiles-setup.service
local gid
gid="$(stat -c '%g' "$journal_dir")"
# Ensure GID is not 4294967295 (GID_INVALID)
[[ "$gid" != "4294967295" ]]
# Ensure the directory is owned by a valid user (root or systemd-journal
# group). The GID should be either 0 (root) or the systemd-journal GID, not
# some bombastically large number
[[ "$gid" -lt 65535 ]]
# Ensure the invalid GID doesn't appear in ACLs
acl_output="$(getfacl "$journal_dir" || true)"
grep -q "4294967295" <<< "$acl_output" && exit 1
rm -fr "$root" "$journal_dir"
}
testcase_boot_param_split() {
local root outdir
root="$(mktemp -d /var/lib/machines/TEST-13-NSPAWN.boot-param-split.XXX)"
outdir="$(mktemp -d)"
create_dummy_container "$root"
# Replace the init binary with a stub that records the argv and environment nspawn passes to it,
# so we can verify that kernel-cmdline-style KEY=VALUE arguments are split between PID 1's
# environment and argv the same way the kernel splits them.
mkdir -p "$root/usr/lib/systemd"
cat >"$root/usr/lib/systemd/systemd" <<'EOF'
#!/bin/bash
set -e
printf '%s\n' "$@" >/output/argv
env >/output/env
EOF
chmod +x "$root/usr/lib/systemd/systemd"
# Cover the assignments that should land in env (FOO=bar, baz-qux=hello → baz_qux), the
# dotted assignments that should stay as argv (systemd.unit=…, some.thing=…), and the malformed
# entries that look env-like but must also stay as argv: empty key (=value), key starting with
# a digit (123=foo), key with characters that aren't valid in an env var name (foo!=bar).
systemd-nspawn --register=no \
--directory="$root" \
--bind="$outdir:/output" \
--boot \
FOO=bar baz-qux=hello systemd.unit=foo.target some.thing=yes plain-arg \
=empty-key 123=leading-digit 'foo!=bad-char'
diff <(printf 'systemd.unit=foo.target\nsome.thing=yes\nplain-arg\n=empty-key\n123=leading-digit\nfoo!=bad-char\n') "$outdir/argv"
grep '^FOO=bar$' >/dev/null "$outdir/env"
grep '^baz_qux=hello$' >/dev/null "$outdir/env"
(! grep -E '^(systemd\.unit|some\.thing)=' >/dev/null "$outdir/env")
(! grep -E '^(FOO|baz_qux)=' >/dev/null "$outdir/argv")
(! grep -E '^(123|foo!?)=' >/dev/null "$outdir/env")
(! grep -E '^=' >/dev/null "$outdir/env")
rm -fr "$root" "$outdir"
}
testcase_cap_net_bind_service() {
local root
root="$(mktemp -d /var/lib/machines/TEST-13-NSPAWN.cap-net-bind-service.XXX)"
create_dummy_container "$root"
# Check that CAP_NET_BIND_SERVICE is available without --private-users
systemd-nspawn --register=no --directory="$root" capsh --has-p=cap_net_bind_service
# Check that CAP_NET_BIND_SERVICE is not available with --private-users=identity
(! systemd-nspawn --register=no --directory="$root" --private-users=identity capsh --has-p=cap_net_bind_service)
# Check that CAP_NET_BIND_SERVICE is not available with --private-users=pick
(! systemd-nspawn --register=no --directory="$root" --private-users=pick capsh --has-p=cap_net_bind_service)
rm -fr "$root"
}
run_testcases