selftests/exec: add file type errno tests (0f71241a) · Commits · 戴 / test

tools/testing/selftests/exec/.gitignore

+1 −0

Original line number	Diff line number	Diff line
		@@ -10,3 +10,4 @@ execveat.denatured
		/recursion-depth
		xxxxxxxx*
		pipe
		S_I*.test

tools/testing/selftests/exec/Makefile

+3 −2

Original line number	Diff line number	Diff line
		@@ -3,7 +3,7 @@ CFLAGS = -Wall
		CFLAGS += -Wno-nonnull
		CFLAGS += -D_GNU_SOURCE

		TEST_PROGS := binfmt_script
		TEST_PROGS := binfmt_script non-regular
		TEST_GEN_PROGS := execveat
		TEST_GEN_FILES := execveat.symlink execveat.denatured script subdir pipe
		# Makefile is a run-time dependency, since it's accessed by the execveat test
		@@ -11,7 +11,8 @@ TEST_FILES := Makefile

		TEST_GEN_PROGS += recursion-depth

		EXTRA_CLEAN := $(OUTPUT)/subdir.moved $(OUTPUT)/execveat.moved $(OUTPUT)/xxxxx*
		EXTRA_CLEAN := $(OUTPUT)/subdir.moved $(OUTPUT)/execveat.moved $(OUTPUT)/xxxxx* \
		$(OUTPUT)/S_I*.test

		include ../lib.mk

tools/testing/selftests/exec/non-regular.c

0 → 100644

+196 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0+
		#include <errno.h>
		#include <fcntl.h>
		#include <stdio.h>
		#include <string.h>
		#include <unistd.h>
		#include <sys/socket.h>
		#include <sys/stat.h>
		#include <sys/sysmacros.h>
		#include <sys/types.h>

		#include "../kselftest_harness.h"

		/* Remove a file, ignoring the result if it didn't exist. */
		void rm(struct __test_metadata _metadata, const char pathname,
		int is_dir)
		{
		int rc;

		if (is_dir)
		rc = rmdir(pathname);
		else
		rc = unlink(pathname);

		if (rc < 0) {
		ASSERT_EQ(errno, ENOENT) {
		TH_LOG("Not ENOENT: %s", pathname);
		}
		} else {
		ASSERT_EQ(rc, 0) {
		TH_LOG("Failed to remove: %s", pathname);
		}
		}
		}

		FIXTURE(file) {
		char *pathname;
		int is_dir;
		};

		FIXTURE_VARIANT(file)
		{
		const char *name;
		int expected;
		int is_dir;
		void (setup)(struct __test_metadata _metadata,
		FIXTURE_DATA(file) *self,
		const FIXTURE_VARIANT(file) *variant);
		int major, minor, mode; /* for mknod() */
		};

		void setup_link(struct __test_metadata *_metadata,
		FIXTURE_DATA(file) *self,
		const FIXTURE_VARIANT(file) *variant)
		{
		const char * const paths[] = {
		"/bin/true",
		"/usr/bin/true",
		};
		int i;

		for (i = 0; i < ARRAY_SIZE(paths); i++) {
		if (access(paths[i], X_OK) == 0) {
		ASSERT_EQ(symlink(paths[i], self->pathname), 0);
		return;
		}
		}
		ASSERT_EQ(1, 0) {
		TH_LOG("Could not find viable 'true' binary");
		}
		}

		FIXTURE_VARIANT_ADD(file, S_IFLNK)
		{
		.name = "S_IFLNK",
		.expected = ELOOP,
		.setup = setup_link,
		};

		void setup_dir(struct __test_metadata *_metadata,
		FIXTURE_DATA(file) *self,
		const FIXTURE_VARIANT(file) *variant)
		{
		ASSERT_EQ(mkdir(self->pathname, 0755), 0);
		}

		FIXTURE_VARIANT_ADD(file, S_IFDIR)
		{
		.name = "S_IFDIR",
		.is_dir = 1,
		.expected = EACCES,
		.setup = setup_dir,
		};

		void setup_node(struct __test_metadata *_metadata,
		FIXTURE_DATA(file) *self,
		const FIXTURE_VARIANT(file) *variant)
		{
		dev_t dev;
		int rc;

		dev = makedev(variant->major, variant->minor);
		rc = mknod(self->pathname, 0755 \| variant->mode, dev);
		ASSERT_EQ(rc, 0) {
		if (errno == EPERM)
		SKIP(return, "Please run as root; cannot mknod(%s)",
		variant->name);
		}
		}

		FIXTURE_VARIANT_ADD(file, S_IFBLK)
		{
		.name = "S_IFBLK",
		.expected = EACCES,
		.setup = setup_node,
		/* /dev/loop0 */
		.major = 7,
		.minor = 0,
		.mode = S_IFBLK,
		};

		FIXTURE_VARIANT_ADD(file, S_IFCHR)
		{
		.name = "S_IFCHR",
		.expected = EACCES,
		.setup = setup_node,
		/* /dev/zero */
		.major = 1,
		.minor = 5,
		.mode = S_IFCHR,
		};

		void setup_fifo(struct __test_metadata *_metadata,
		FIXTURE_DATA(file) *self,
		const FIXTURE_VARIANT(file) *variant)
		{
		ASSERT_EQ(mkfifo(self->pathname, 0755), 0);
		}

		FIXTURE_VARIANT_ADD(file, S_IFIFO)
		{
		.name = "S_IFIFO",
		.expected = EACCES,
		.setup = setup_fifo,
		};

		FIXTURE_SETUP(file)
		{
		ASSERT_GT(asprintf(&self->pathname, "%s.test", variant->name), 6);
		self->is_dir = variant->is_dir;

		rm(_metadata, self->pathname, variant->is_dir);
		variant->setup(_metadata, self, variant);
		}

		FIXTURE_TEARDOWN(file)
		{
		rm(_metadata, self->pathname, self->is_dir);
		}

		TEST_F(file, exec_errno)
		{
		char * const argv[2] = { (char * const)self->pathname, NULL };

		EXPECT_LT(execv(argv[0], argv), 0);
		EXPECT_EQ(errno, variant->expected);
		}

		/* S_IFSOCK */
		FIXTURE(sock)
		{
		int fd;
		};

		FIXTURE_SETUP(sock)
		{
		self->fd = socket(AF_INET, SOCK_STREAM, 0);
		ASSERT_GE(self->fd, 0);
		}

		FIXTURE_TEARDOWN(sock)
		{
		if (self->fd >= 0)
		ASSERT_EQ(close(self->fd), 0);
		}

		TEST_F(sock, exec_errno)
		{
		char * const argv[2] = { " magic socket ", NULL };
		char * const envp[1] = { NULL };

		EXPECT_LT(fexecve(self->fd, argv, envp), 0);
		EXPECT_EQ(errno, EACCES);
		}

		TEST_HARNESS_MAIN

Admin message