HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

test/units/TEST-13-NSPAWN.nspawn.sh

69,043 bytesGit mode 100755Download original fileLGPL-2.1-or-later

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