19315930715

Committed 12 Nov 2025 11:39PM UTC coverage: 72.251% (-0.2%) from 72.412%

Build # 19315930715

Build Type

push

github

Committed by

bluca

Commit Message

mkosi: update debian commit reference to efdd7a637

* efdd7a6377 Install new file for upstream build
* 9ebdc6099e d/rules: enable 10-systemd-logind-root-ignore-inhibitors.rules.example on Ubuntu
* 1255cc7663 initramfs-tools: only skip chzdev rules if zdev_early=0
* 4675b281ee d/t/boot-and-services: skip apparmor test on armhf
* 214d6e37b2 d/t/boot-and-services: run transient unit to check syslog messages
* f4e196aa26 d/t/boot-and-services: tweak test_rsyslog regex
* dbd366a43e Install new files for upstream build
* bb7f8ef532 Install new files for upstream build
* efa7cee8a7 Install new file for upstream build
* 95aa1d1685 Install new file for upstream build
* b770f0f01b kernel-install: skip 55-initrd.install when an initrd generator is configured
* af8d1e3134 Update changelog for 258.1-2 release
* 2d0e73cd14 d/libnss-systemd.postinst: Ensure module is enabled for all four databases

Run Details

306471 of 424176 relevant lines covered (72.25%)

1239443.53 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.27

/src/test/test-exec-util.c

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include <stdlib.h>
#include <sys/stat.h>
#include <unistd.h>

#include "alloc-util.h"
#include "constants.h"
#include "env-util.h"
#include "exec-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "fs-util.h"
#include "log.h"
#include "path-util.h"
#include "rm-rf.h"
#include "string-util.h"
#include "strv.h"
#include "tests.h"
#include "tmpfile-util.h"

static int here = 0, here2 = 0, here3 = 0;
static void *ignore_stdout_args[] = { &here, &here2, &here3 };

/* noop handlers, just check that arguments are passed correctly */
static int ignore_stdout_func(int fd, void *arg) {
        assert_se(fd >= 0);
        assert_se(arg == &here);
        safe_close(fd);

        return 0;
}
static int ignore_stdout_func2(int fd, void *arg) {
        assert_se(fd >= 0);
        assert_se(arg == &here2);
        safe_close(fd);

        return 0;
}
static int ignore_stdout_func3(int fd, void *arg) {
        assert_se(fd >= 0);
        assert_se(arg == &here3);
        safe_close(fd);

        return 0;
}

static const gather_stdout_callback_t ignore_stdout[] = {
        ignore_stdout_func,
        ignore_stdout_func2,
        ignore_stdout_func3,
};

static void test_execute_directory_one(bool gather_stdout) {
        _cleanup_(rm_rf_physical_and_freep) char *tmp_lo = NULL, *tmp_hi = NULL;
        const char *name, *name2, *name3,
                *overridden, *override,
                *masked, *mask,
                *masked2, *mask2,   /* the mask is non-executable */
                *masked2e, *mask2e; /* the mask is executable */

        log_info("/* %s (%s) */", __func__, gather_stdout ? "gathering stdout" : "asynchronous");

        assert_se(mkdtemp_malloc("/tmp/test-exec-util.lo.XXXXXXX", &tmp_lo) >= 0);
        assert_se(mkdtemp_malloc("/tmp/test-exec-util.hi.XXXXXXX", &tmp_hi) >= 0);

        const char * dirs[] = { tmp_hi, tmp_lo, NULL };

        name = strjoina(tmp_lo, "/script");
        name2 = strjoina(tmp_hi, "/script2");
        name3 = strjoina(tmp_lo, "/useless");
        overridden = strjoina(tmp_lo, "/overridden");
        override = strjoina(tmp_hi, "/overridden");
        masked = strjoina(tmp_lo, "/masked");
        mask = strjoina(tmp_hi, "/masked");
        masked2 = strjoina(tmp_lo, "/masked2");
        mask2 = strjoina(tmp_hi, "/masked2");
        masked2e = strjoina(tmp_lo, "/masked2e");
        mask2e = strjoina(tmp_hi, "/masked2e");

        assert_se(write_string_file(name,
                                    "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works",
                                    WRITE_STRING_FILE_CREATE) == 0);
        assert_se(write_string_file(name2,
                                    "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works2",
                                    WRITE_STRING_FILE_CREATE) == 0);
        assert_se(write_string_file(overridden,
                                    "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed",
                                    WRITE_STRING_FILE_CREATE) == 0);
        assert_se(write_string_file(override,
                                    "#!/bin/sh\necho 'Executing '$0",
                                    WRITE_STRING_FILE_CREATE) == 0);
        assert_se(write_string_file(masked,
                                    "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed",
                                    WRITE_STRING_FILE_CREATE) == 0);
        assert_se(write_string_file(masked2,
                                    "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed",
                                    WRITE_STRING_FILE_CREATE) == 0);
        assert_se(write_string_file(masked2e,
                                    "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed",
                                    WRITE_STRING_FILE_CREATE) == 0);
        assert_se(symlink("/dev/null", mask) == 0);
        assert_se(touch(mask2) == 0);
        assert_se(touch(mask2e) == 0);
        assert_se(touch(name3) >= 0);

        assert_se(chmod(name, 0755) == 0);
        assert_se(chmod(name2, 0755) == 0);
        assert_se(chmod(overridden, 0755) == 0);
        assert_se(chmod(override, 0755) == 0);
        assert_se(chmod(masked, 0755) == 0);
        assert_se(chmod(masked2, 0755) == 0);
        assert_se(chmod(masked2e, 0755) == 0);
        assert_se(chmod(mask2e, 0755) == 0);

        if (access(name, X_OK) < 0 && ERRNO_IS_PRIVILEGE(errno))
                return;

        if (gather_stdout)
                execute_directories("test", dirs, DEFAULT_TIMEOUT_USEC, ignore_stdout, ignore_stdout_args, NULL, NULL, EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS);
        else
                execute_directories("test", dirs, DEFAULT_TIMEOUT_USEC, NULL, NULL, NULL, NULL, EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS);

        assert_se(chdir(tmp_lo) == 0);
        assert_se(access("it_works", F_OK) >= 0);
        assert_se(access("failed", F_OK) < 0);

        assert_se(chdir(tmp_hi) == 0);
        assert_se(access("it_works2", F_OK) >= 0);
        assert_se(access("failed", F_OK) < 0);
}

TEST(execute_directory) {
        test_execute_directory_one(true);
        test_execute_directory_one(false);
}

TEST(execution_order) {
        _cleanup_(rm_rf_physical_and_freep) char *tmp_lo = NULL, *tmp_hi = NULL;
        const char *name, *name2, *name3, *overridden, *override, *masked, *mask;
        const char *output, *t;
        _cleanup_free_ char *contents = NULL;

        assert_se(mkdtemp_malloc("/tmp/test-exec-util-lo.XXXXXXX", &tmp_lo) >= 0);
        assert_se(mkdtemp_malloc("/tmp/test-exec-util-hi.XXXXXXX", &tmp_hi) >= 0);

        const char *dirs[] = { tmp_hi, tmp_lo, NULL };

        output = strjoina(tmp_hi, "/output");

        log_info("/* %s >>%s */", __func__, output);

        /* write files in "random" order */
        name2 = strjoina(tmp_lo, "/90-bar");
        name = strjoina(tmp_hi, "/80-foo");
        name3 = strjoina(tmp_lo, "/last");
        overridden = strjoina(tmp_lo, "/30-override");
        override = strjoina(tmp_hi, "/30-override");
        masked = strjoina(tmp_lo, "/10-masked");
        mask = strjoina(tmp_hi, "/10-masked");

        t = strjoina("#!/bin/sh\necho $(basename $0) >>", output);
        assert_se(write_string_file(name, t, WRITE_STRING_FILE_CREATE) == 0);

        t = strjoina("#!/bin/sh\necho $(basename $0) >>", output);
        assert_se(write_string_file(name2, t, WRITE_STRING_FILE_CREATE) == 0);

        t = strjoina("#!/bin/sh\necho $(basename $0) >>", output);
        assert_se(write_string_file(name3, t, WRITE_STRING_FILE_CREATE) == 0);

        t = strjoina("#!/bin/sh\necho OVERRIDDEN >>", output);
        assert_se(write_string_file(overridden, t, WRITE_STRING_FILE_CREATE) == 0);

        t = strjoina("#!/bin/sh\necho $(basename $0) >>", output);
        assert_se(write_string_file(override, t, WRITE_STRING_FILE_CREATE) == 0);

        t = strjoina("#!/bin/sh\necho MASKED >>", output);
        assert_se(write_string_file(masked, t, WRITE_STRING_FILE_CREATE) == 0);

        assert_se(symlink("/dev/null", mask) == 0);

        assert_se(chmod(name, 0755) == 0);
        assert_se(chmod(name2, 0755) == 0);
        assert_se(chmod(name3, 0755) == 0);
        assert_se(chmod(overridden, 0755) == 0);
        assert_se(chmod(override, 0755) == 0);
        assert_se(chmod(masked, 0755) == 0);

        if (access(name, X_OK) < 0 && ERRNO_IS_PRIVILEGE(errno))
                return;

        execute_directories(__func__,
                            dirs, DEFAULT_TIMEOUT_USEC, ignore_stdout, ignore_stdout_args, NULL, NULL,
                            EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS);

        assert_se(read_full_file(output, &contents, NULL) >= 0);
        ASSERT_STREQ(contents, "30-override\n80-foo\n90-bar\nlast\n");
}

static int gather_stdout_one(int fd, void *arg) {
        char ***s = arg, *t;
        char buf[128] = {};

        assert_se(s);
        assert_se(read(fd, buf, sizeof buf) >= 0);
        safe_close(fd);

        assert_se(t = strndup(buf, sizeof buf));
        assert_se(strv_push(s, t) >= 0);

        return 0;
}
static int gather_stdout_two(int fd, void *arg) {
        char ***s = arg;

        STRV_FOREACH(t, *s)
                assert_se(write(fd, *t, strlen(*t)) == (ssize_t) strlen(*t));
        safe_close(fd);

        return 0;
}
static int gather_stdout_three(int fd, void *arg) {
        char **s = arg;
        char buf[128] = {};

        assert_se(read(fd, buf, sizeof buf - 1) > 0);
        safe_close(fd);
        assert_se(*s = strndup(buf, sizeof buf));

        return 0;
}

const gather_stdout_callback_t gather_stdouts[] = {
        gather_stdout_one,
        gather_stdout_two,
        gather_stdout_three,
};

TEST(stdout_gathering) {
        _cleanup_(rm_rf_physical_and_freep) char *tmpdir = NULL;
        const char *name, *name2, *name3;
        int r;

        char **tmp = NULL; /* this is only used in the forked process, no cleanup here */
        _cleanup_free_ char *output = NULL;

        void* args[] = {&tmp, &tmp, &output};

        assert_se(mkdtemp_malloc("/tmp/test-exec-util.XXXXXXX", &tmpdir) >= 0);

        const char *dirs[] = { tmpdir, NULL };

        /* write files */
        name = strjoina(tmpdir, "/10-foo");
        name2 = strjoina(tmpdir, "/20-bar");
        name3 = strjoina(tmpdir, "/30-last");

        assert_se(write_string_file(name,
                                    "#!/bin/sh\necho a\necho b\necho c\n",
                                    WRITE_STRING_FILE_CREATE) == 0);
        assert_se(write_string_file(name2,
                                    "#!/bin/sh\necho d\n",
                                    WRITE_STRING_FILE_CREATE) == 0);
        assert_se(write_string_file(name3,
                                    "#!/bin/sh\nsleep 1",
                                    WRITE_STRING_FILE_CREATE) == 0);

        assert_se(chmod(name, 0755) == 0);
        assert_se(chmod(name2, 0755) == 0);
        assert_se(chmod(name3, 0755) == 0);

        if (access(name, X_OK) < 0 && ERRNO_IS_PRIVILEGE(errno))
                return;

        r = execute_directories(__func__,
                                dirs, DEFAULT_TIMEOUT_USEC, gather_stdouts, args, NULL, NULL,
                                EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS);
        assert_se(r >= 0);

        log_info("got: %s", output);

        ASSERT_STREQ(output, "a\nb\nc\nd\n");
}

TEST(environment_gathering) {
        _cleanup_(rm_rf_physical_and_freep) char *tmpdir = NULL;
        const char *name, *name2, *name3, *old;
        int r;

        char **tmp = NULL; /* this is only used in the forked process, no cleanup here */
        _cleanup_strv_free_ char **env = NULL;

        void* const args[] = { &tmp, &tmp, &env };

        assert_se(mkdtemp_malloc("/tmp/test-exec-util.XXXXXXX", &tmpdir) >= 0);

        const char *dirs[] = { tmpdir, NULL };

        /* write files */
        name = strjoina(tmpdir, "/10-foo");
        name2 = strjoina(tmpdir, "/20-bar");
        name3 = strjoina(tmpdir, "/30-last");

        assert_se(write_string_file(name,
                                    "#!/bin/sh\n"
                                    "echo A=23\n",
                                    WRITE_STRING_FILE_CREATE) == 0);
        assert_se(write_string_file(name2,
                                    "#!/bin/sh\n"
                                    "echo A=22:$A\n\n\n",            /* substitution from previous generator */
                                    WRITE_STRING_FILE_CREATE) == 0);
        assert_se(write_string_file(name3,
                                    "#!/bin/sh\n"
                                    "echo A=$A:24\n"
                                    "echo B=12\n"
                                    "echo C=000\n"
                                    "echo C=001\n"                    /* variable overwriting */
                                     /* various invalid entries */
                                    "echo unset A\n"
                                    "echo unset A=\n"
                                    "echo unset A=B\n"
                                    "echo unset \n"
                                    "echo A B=C\n"
                                    "echo A\n"
                                    /* test variable assignment without newline */
                                    "echo PATH=$PATH:/no/such/file",   /* no newline */
                                    WRITE_STRING_FILE_CREATE) == 0);

        assert_se(chmod(name, 0755) == 0);
        assert_se(chmod(name2, 0755) == 0);
        assert_se(chmod(name3, 0755) == 0);

        /* When booting in containers or without initrd there might not be any PATH in the environment and if
         * there is no PATH /bin/sh built-in PATH may leak and override systemd's default path which is not
         * good. Force our own PATH in environment, to prevent expansion of sh built-in $PATH */
        old = getenv("PATH");
        r = setenv("PATH", "no-sh-built-in-path", 1);
        assert_se(r >= 0);

        if (access(name, X_OK) < 0 && ERRNO_IS_PRIVILEGE(errno))
                return;

        r = execute_directories(__func__,
                                dirs, DEFAULT_TIMEOUT_USEC, gather_environment, args, NULL, NULL,
                                EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS);
        assert_se(r >= 0);

        STRV_FOREACH(p, env)
                log_info("got env: \"%s\"", *p);

        ASSERT_STREQ(strv_env_get(env, "A"), "22:23:24");
        ASSERT_STREQ(strv_env_get(env, "B"), "12");
        ASSERT_STREQ(strv_env_get(env, "C"), "001");
        ASSERT_STREQ(strv_env_get(env, "PATH"), "no-sh-built-in-path:/no/such/file");

        /* Now retest with some "default" path passed. */
        env = strv_free(env);
        env = strv_new("PATH=" DEFAULT_PATH_WITHOUT_SBIN);
        assert_se(env);

        r = execute_directories(__func__,
                                dirs, DEFAULT_TIMEOUT_USEC, gather_environment, args, NULL, env,
                                EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS);
        assert_se(r >= 0);

        STRV_FOREACH(p, env)
                log_info("got env: \"%s\"", *p);

        ASSERT_STREQ(strv_env_get(env, "A"), "22:23:24");
        ASSERT_STREQ(strv_env_get(env, "B"), "12");
        ASSERT_STREQ(strv_env_get(env, "C"), "001");
        ASSERT_STREQ(strv_env_get(env, "PATH"), DEFAULT_PATH_WITHOUT_SBIN ":/no/such/file");

        /* reset environ PATH */
        assert_se(set_unset_env("PATH", old, true) == 0);
}

TEST(error_catching) {
        _cleanup_(rm_rf_physical_and_freep) char *tmpdir = NULL;
        const char *name, *name2, *name3;
        int r;

        assert_se(mkdtemp_malloc("/tmp/test-exec-util.XXXXXXX", &tmpdir) >= 0);

        const char *dirs[] = { tmpdir, NULL };

        /* write files */
        name = strjoina(tmpdir, "/10-foo");
        name2 = strjoina(tmpdir, "/20-bar");
        name3 = strjoina(tmpdir, "/30-last");

        assert_se(write_string_file(name,
                                    "#!/bin/sh\necho a\necho b\necho c\n",
                                    WRITE_STRING_FILE_CREATE) == 0);
        assert_se(write_string_file(name2,
                                    "#!/bin/sh\nexit 42\n",
                                    WRITE_STRING_FILE_CREATE) == 0);
        assert_se(write_string_file(name3,
                                    "#!/bin/sh\nexit 12",
                                    WRITE_STRING_FILE_CREATE) == 0);

        assert_se(chmod(name, 0755) == 0);
        assert_se(chmod(name2, 0755) == 0);
        assert_se(chmod(name3, 0755) == 0);

        if (access(name, X_OK) < 0 && ERRNO_IS_PRIVILEGE(errno))
                return;

        r = execute_directories(__func__,
                                dirs, DEFAULT_TIMEOUT_USEC,
                                /* callbacks = */ NULL, /* callback_args = */ NULL,
                                /* argv = */ NULL, /* envp = */ NULL, /* flags = */ 0);

        /* we should exit with the error code of the first script that failed */
        assert_se(r == 42);
}

TEST(exec_command_flags_from_strv) {
        ExecCommandFlags flags = 0;
        char **valid_strv = STRV_MAKE("no-env-expand", "no-setuid", "ignore-failure");
        char **invalid_strv = STRV_MAKE("no-env-expand", "no-setuid", "nonexistent-option", "ignore-failure");
        int r;

        r = exec_command_flags_from_strv(valid_strv, &flags);

        assert_se(r == 0);
        assert_se(FLAGS_SET(flags, EXEC_COMMAND_NO_ENV_EXPAND));
        assert_se(FLAGS_SET(flags, EXEC_COMMAND_NO_SETUID));
        assert_se(FLAGS_SET(flags, EXEC_COMMAND_IGNORE_FAILURE));
        assert_se(!FLAGS_SET(flags, EXEC_COMMAND_FULLY_PRIVILEGED));

        r = exec_command_flags_from_strv(invalid_strv, &flags);

        assert_se(r == -EINVAL);
}

TEST(exec_command_flags_to_strv) {
        _cleanup_strv_free_ char **opts = NULL;

        ASSERT_OK(exec_command_flags_to_strv(EXEC_COMMAND_NO_ENV_EXPAND|EXEC_COMMAND_IGNORE_FAILURE, &opts));
        assert_se(strv_equal(opts, STRV_MAKE("ignore-failure", "no-env-expand")));

        opts = strv_free(opts);

        ASSERT_OK(exec_command_flags_to_strv(0, &opts));
        assert_se(strv_isempty(opts));

        opts = strv_free(opts);

        ASSERT_ERROR(exec_command_flags_to_strv(1U << 20, &opts), EINVAL);
}

DEFINE_TEST_MAIN(LOG_DEBUG);

1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3	#include <stdlib.h>
4	#include <sys/stat.h>
5	#include <unistd.h>
6
7	#include "alloc-util.h"
8	#include "constants.h"
9	#include "env-util.h"
10	#include "exec-util.h"
11	#include "fd-util.h"
12	#include "fileio.h"
13	#include "fs-util.h"
14	#include "log.h"
15	#include "path-util.h"
16	#include "rm-rf.h"
17	#include "string-util.h"
18	#include "strv.h"
19	#include "tests.h"
20	#include "tmpfile-util.h"
21
22	static int here = 0, here2 = 0, here3 = 0;
23	static void *ignore_stdout_args[] = { &here, &here2, &here3 };
24
25	/* noop handlers, just check that arguments are passed correctly */
26	static int ignore_stdout_func(int fd, void *arg) {	7✔
27	assert_se(fd >= 0);	7✔
28	assert_se(arg == &here);	7✔
29	safe_close(fd);	7✔
30
31	return 0;	7✔
32	}
33	static int ignore_stdout_func2(int fd, void *arg) {	2✔
34	assert_se(fd >= 0);	2✔
35	assert_se(arg == &here2);	2✔
36	safe_close(fd);	2✔
37
38	return 0;	2✔
39	}
40	static int ignore_stdout_func3(int fd, void *arg) {	2✔
41	assert_se(fd >= 0);	2✔
42	assert_se(arg == &here3);	2✔
43	safe_close(fd);	2✔
44
45	return 0;	2✔
46	}
47
48	static const gather_stdout_callback_t ignore_stdout[] = {
49	ignore_stdout_func,
50	ignore_stdout_func2,
51	ignore_stdout_func3,
52	};
53
54	static void test_execute_directory_one(bool gather_stdout) {	2✔
55	_cleanup_(rm_rf_physical_and_freep) char tmp_lo = NULL, tmp_hi = NULL;	2✔
56	const char name, name2, *name3,	2✔
57	overridden, override,
58	masked, mask,
59	masked2, mask2, /* the mask is non-executable */
60	masked2e, mask2e; /* the mask is executable */
61
62	log_info("/* %s (%s) */", __func__, gather_stdout ? "gathering stdout" : "asynchronous");	3✔
63
64	assert_se(mkdtemp_malloc("/tmp/test-exec-util.lo.XXXXXXX", &tmp_lo) >= 0);	2✔
65	assert_se(mkdtemp_malloc("/tmp/test-exec-util.hi.XXXXXXX", &tmp_hi) >= 0);	2✔
66
67	const char * dirs[] = { tmp_hi, tmp_lo, NULL };	2✔
68
69	name = strjoina(tmp_lo, "/script");	10✔
70	name2 = strjoina(tmp_hi, "/script2");	10✔
71	name3 = strjoina(tmp_lo, "/useless");	10✔
72	overridden = strjoina(tmp_lo, "/overridden");	10✔
73	override = strjoina(tmp_hi, "/overridden");	10✔
74	masked = strjoina(tmp_lo, "/masked");	10✔
75	mask = strjoina(tmp_hi, "/masked");	10✔
76	masked2 = strjoina(tmp_lo, "/masked2");	10✔
77	mask2 = strjoina(tmp_hi, "/masked2");	10✔
78	masked2e = strjoina(tmp_lo, "/masked2e");	10✔
79	mask2e = strjoina(tmp_hi, "/masked2e");	10✔
80
81	assert_se(write_string_file(name,	2✔
82	"#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works",
83	WRITE_STRING_FILE_CREATE) == 0);
84	assert_se(write_string_file(name2,	2✔
85	"#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works2",
86	WRITE_STRING_FILE_CREATE) == 0);
87	assert_se(write_string_file(overridden,	2✔
88	"#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed",
89	WRITE_STRING_FILE_CREATE) == 0);
90	assert_se(write_string_file(override,	2✔
91	"#!/bin/sh\necho 'Executing '$0",
92	WRITE_STRING_FILE_CREATE) == 0);
93	assert_se(write_string_file(masked,	2✔
94	"#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed",
95	WRITE_STRING_FILE_CREATE) == 0);
96	assert_se(write_string_file(masked2,	2✔
97	"#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed",
98	WRITE_STRING_FILE_CREATE) == 0);
99	assert_se(write_string_file(masked2e,	2✔
100	"#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed",
101	WRITE_STRING_FILE_CREATE) == 0);
102	assert_se(symlink("/dev/null", mask) == 0);	2✔
103	assert_se(touch(mask2) == 0);	2✔
104	assert_se(touch(mask2e) == 0);	2✔
105	assert_se(touch(name3) >= 0);	2✔
106
107	assert_se(chmod(name, 0755) == 0);	2✔
108	assert_se(chmod(name2, 0755) == 0);	2✔
109	assert_se(chmod(overridden, 0755) == 0);	2✔
110	assert_se(chmod(override, 0755) == 0);	2✔
111	assert_se(chmod(masked, 0755) == 0);	2✔
112	assert_se(chmod(masked2, 0755) == 0);	2✔
113	assert_se(chmod(masked2e, 0755) == 0);	2✔
114	assert_se(chmod(mask2e, 0755) == 0);	2✔
115
116	if (access(name, X_OK) < 0 && ERRNO_IS_PRIVILEGE(errno))	2✔
117	return;	×
118
119	if (gather_stdout)	2✔
120	execute_directories("test", dirs, DEFAULT_TIMEOUT_USEC, ignore_stdout, ignore_stdout_args, NULL, NULL, EXEC_DIR_PARALLEL \| EXEC_DIR_IGNORE_ERRORS);	1✔
121	else
122	execute_directories("test", dirs, DEFAULT_TIMEOUT_USEC, NULL, NULL, NULL, NULL, EXEC_DIR_PARALLEL \| EXEC_DIR_IGNORE_ERRORS);	1✔
123
124	assert_se(chdir(tmp_lo) == 0);	2✔
125	assert_se(access("it_works", F_OK) >= 0);	2✔
126	assert_se(access("failed", F_OK) < 0);	2✔
127
128	assert_se(chdir(tmp_hi) == 0);	2✔
129	assert_se(access("it_works2", F_OK) >= 0);	2✔
130	assert_se(access("failed", F_OK) < 0);	2✔
131	}
132
133	TEST(execute_directory) {	1✔
134	test_execute_directory_one(true);	1✔
135	test_execute_directory_one(false);	1✔
136	}	1✔
137
138	TEST(execution_order) {	1✔
139	_cleanup_(rm_rf_physical_and_freep) char tmp_lo = NULL, tmp_hi = NULL;	1✔
140	const char name, name2, name3, overridden, override, masked, *mask;	1✔
141	const char output, t;	1✔
142	_cleanup_free_ char *contents = NULL;	1✔
143
144	assert_se(mkdtemp_malloc("/tmp/test-exec-util-lo.XXXXXXX", &tmp_lo) >= 0);	1✔
145	assert_se(mkdtemp_malloc("/tmp/test-exec-util-hi.XXXXXXX", &tmp_hi) >= 0);	1✔
146
147	const char *dirs[] = { tmp_hi, tmp_lo, NULL };	1✔
148
149	output = strjoina(tmp_hi, "/output");	5✔
150
151	log_info("/* %s >>%s */", __func__, output);	1✔
152
153	/* write files in "random" order */
154	name2 = strjoina(tmp_lo, "/90-bar");	5✔
155	name = strjoina(tmp_hi, "/80-foo");	5✔
156	name3 = strjoina(tmp_lo, "/last");	5✔
157	overridden = strjoina(tmp_lo, "/30-override");	5✔
158	override = strjoina(tmp_hi, "/30-override");	5✔
159	masked = strjoina(tmp_lo, "/10-masked");	5✔
160	mask = strjoina(tmp_hi, "/10-masked");	5✔
161
162	t = strjoina("#!/bin/sh\necho $(basename $0) >>", output);	5✔
163	assert_se(write_string_file(name, t, WRITE_STRING_FILE_CREATE) == 0);	1✔
164
165	t = strjoina("#!/bin/sh\necho $(basename $0) >>", output);	5✔
166	assert_se(write_string_file(name2, t, WRITE_STRING_FILE_CREATE) == 0);	1✔
167
168	t = strjoina("#!/bin/sh\necho $(basename $0) >>", output);	5✔
169	assert_se(write_string_file(name3, t, WRITE_STRING_FILE_CREATE) == 0);	1✔
170
171	t = strjoina("#!/bin/sh\necho OVERRIDDEN >>", output);	5✔
172	assert_se(write_string_file(overridden, t, WRITE_STRING_FILE_CREATE) == 0);	1✔
173
174	t = strjoina("#!/bin/sh\necho $(basename $0) >>", output);	5✔
175	assert_se(write_string_file(override, t, WRITE_STRING_FILE_CREATE) == 0);	1✔
176
177	t = strjoina("#!/bin/sh\necho MASKED >>", output);	5✔
178	assert_se(write_string_file(masked, t, WRITE_STRING_FILE_CREATE) == 0);	1✔
179
180	assert_se(symlink("/dev/null", mask) == 0);	1✔
181
182	assert_se(chmod(name, 0755) == 0);	1✔
183	assert_se(chmod(name2, 0755) == 0);	1✔
184	assert_se(chmod(name3, 0755) == 0);	1✔
185	assert_se(chmod(overridden, 0755) == 0);	1✔
186	assert_se(chmod(override, 0755) == 0);	1✔
187	assert_se(chmod(masked, 0755) == 0);	1✔
188
189	if (access(name, X_OK) < 0 && ERRNO_IS_PRIVILEGE(errno))	1✔
190	return;	×
191
192	execute_directories(__func__,	1✔
193	dirs, DEFAULT_TIMEOUT_USEC, ignore_stdout, ignore_stdout_args, NULL, NULL,
194	EXEC_DIR_PARALLEL \| EXEC_DIR_IGNORE_ERRORS);
195
196	assert_se(read_full_file(output, &contents, NULL) >= 0);	1✔
197	ASSERT_STREQ(contents, "30-override\n80-foo\n90-bar\nlast\n");	1✔
198	}
199
200	static int gather_stdout_one(int fd, void *arg) {	3✔
201	char **s = arg, t;	3✔
202	char buf[128] = {};	3✔
203
204	assert_se(s);	3✔
205	assert_se(read(fd, buf, sizeof buf) >= 0);	3✔
206	safe_close(fd);	3✔
207
208	assert_se(t = strndup(buf, sizeof buf));	3✔
209	assert_se(strv_push(s, t) >= 0);	3✔
210
211	return 0;	3✔
212	}
213	static int gather_stdout_two(int fd, void *arg) {	1✔
214	char ***s = arg;	1✔
215
216	STRV_FOREACH(t, *s)	4✔
217	assert_se(write(fd, t, strlen(t)) == (ssize_t) strlen(*t));	3✔
218	safe_close(fd);	1✔
219
220	return 0;	1✔
221	}
222	static int gather_stdout_three(int fd, void *arg) {	1✔
223	char **s = arg;	1✔
224	char buf[128] = {};	1✔
225
226	assert_se(read(fd, buf, sizeof buf - 1) > 0);	1✔
227	safe_close(fd);	1✔
228	assert_se(*s = strndup(buf, sizeof buf));	1✔
229
230	return 0;	1✔
231	}
232
233	const gather_stdout_callback_t gather_stdouts[] = {
234	gather_stdout_one,
235	gather_stdout_two,
236	gather_stdout_three,
237	};
238
239	TEST(stdout_gathering) {	1✔
240	_cleanup_(rm_rf_physical_and_freep) char *tmpdir = NULL;	×
241	const char name, name2, *name3;	1✔
242	int r;	1✔
243
244	char *tmp = NULL; / this is only used in the forked process, no cleanup here */	1✔
245	_cleanup_free_ char *output = NULL;	1✔
246
247	void* args[] = {&tmp, &tmp, &output};	1✔
248
249	assert_se(mkdtemp_malloc("/tmp/test-exec-util.XXXXXXX", &tmpdir) >= 0);	1✔
250
251	const char *dirs[] = { tmpdir, NULL };	1✔
252
253	/* write files */
254	name = strjoina(tmpdir, "/10-foo");	5✔
255	name2 = strjoina(tmpdir, "/20-bar");	5✔
256	name3 = strjoina(tmpdir, "/30-last");	5✔
257
258	assert_se(write_string_file(name,	1✔
259	"#!/bin/sh\necho a\necho b\necho c\n",
260	WRITE_STRING_FILE_CREATE) == 0);
261	assert_se(write_string_file(name2,	1✔
262	"#!/bin/sh\necho d\n",
263	WRITE_STRING_FILE_CREATE) == 0);
264	assert_se(write_string_file(name3,	1✔
265	"#!/bin/sh\nsleep 1",
266	WRITE_STRING_FILE_CREATE) == 0);
267
268	assert_se(chmod(name, 0755) == 0);	1✔
269	assert_se(chmod(name2, 0755) == 0);	1✔
270	assert_se(chmod(name3, 0755) == 0);	1✔
271
272	if (access(name, X_OK) < 0 && ERRNO_IS_PRIVILEGE(errno))	1✔
273	return;	×
274
275	r = execute_directories(__func__,	1✔
276	dirs, DEFAULT_TIMEOUT_USEC, gather_stdouts, args, NULL, NULL,
277	EXEC_DIR_PARALLEL \| EXEC_DIR_IGNORE_ERRORS);
278	assert_se(r >= 0);	1✔
279
280	log_info("got: %s", output);	1✔
281
282	ASSERT_STREQ(output, "a\nb\nc\nd\n");	1✔
283	}
284
285	TEST(environment_gathering) {	1✔
286	_cleanup_(rm_rf_physical_and_freep) char *tmpdir = NULL;	1✔
287	const char name, name2, name3, old;	1✔
288	int r;	1✔
289
290	char *tmp = NULL; / this is only used in the forked process, no cleanup here */	1✔
291	_cleanup_strv_free_ char **env = NULL;	×
292
293	void* const args[] = { &tmp, &tmp, &env };	1✔
294
295	assert_se(mkdtemp_malloc("/tmp/test-exec-util.XXXXXXX", &tmpdir) >= 0);	1✔
296
297	const char *dirs[] = { tmpdir, NULL };	1✔
298
299	/* write files */
300	name = strjoina(tmpdir, "/10-foo");	5✔
301	name2 = strjoina(tmpdir, "/20-bar");	5✔
302	name3 = strjoina(tmpdir, "/30-last");	5✔
303
304	assert_se(write_string_file(name,	1✔
305	"#!/bin/sh\n"
306	"echo A=23\n",
307	WRITE_STRING_FILE_CREATE) == 0);
308	assert_se(write_string_file(name2,	1✔
309	"#!/bin/sh\n"
310	"echo A=22:$A\n\n\n", /* substitution from previous generator */
311	WRITE_STRING_FILE_CREATE) == 0);
312	assert_se(write_string_file(name3,	1✔
313	"#!/bin/sh\n"
314	"echo A=$A:24\n"
315	"echo B=12\n"
316	"echo C=000\n"
317	"echo C=001\n" /* variable overwriting */
318	/* various invalid entries */
319	"echo unset A\n"
320	"echo unset A=\n"
321	"echo unset A=B\n"
322	"echo unset \n"
323	"echo A B=C\n"
324	"echo A\n"
325	/* test variable assignment without newline */
326	"echo PATH=$PATH:/no/such/file", /* no newline */
327	WRITE_STRING_FILE_CREATE) == 0);
328
329	assert_se(chmod(name, 0755) == 0);	1✔
330	assert_se(chmod(name2, 0755) == 0);	1✔
331	assert_se(chmod(name3, 0755) == 0);	1✔
332
333	/* When booting in containers or without initrd there might not be any PATH in the environment and if
334	* there is no PATH /bin/sh built-in PATH may leak and override systemd's default path which is not
335	* good. Force our own PATH in environment, to prevent expansion of sh built-in $PATH */
336	old = getenv("PATH");	1✔
337	r = setenv("PATH", "no-sh-built-in-path", 1);	1✔
338	assert_se(r >= 0);	1✔
339
340	if (access(name, X_OK) < 0 && ERRNO_IS_PRIVILEGE(errno))	1✔
341	return;	×
342
343	r = execute_directories(__func__,	1✔
344	dirs, DEFAULT_TIMEOUT_USEC, gather_environment, args, NULL, NULL,
345	EXEC_DIR_PARALLEL \| EXEC_DIR_IGNORE_ERRORS);
346	assert_se(r >= 0);	1✔
347
348	STRV_FOREACH(p, env)	5✔
349	log_info("got env: \"%s\"", *p);	4✔
350
351	ASSERT_STREQ(strv_env_get(env, "A"), "22:23:24");	1✔
352	ASSERT_STREQ(strv_env_get(env, "B"), "12");	1✔
353	ASSERT_STREQ(strv_env_get(env, "C"), "001");	1✔
354	ASSERT_STREQ(strv_env_get(env, "PATH"), "no-sh-built-in-path:/no/such/file");	1✔
355
356	/* Now retest with some "default" path passed. */
357	env = strv_free(env);	1✔
358	env = strv_new("PATH=" DEFAULT_PATH_WITHOUT_SBIN);	1✔
359	assert_se(env);	1✔
360
361	r = execute_directories(__func__,	1✔
362	dirs, DEFAULT_TIMEOUT_USEC, gather_environment, args, NULL, env,
363	EXEC_DIR_PARALLEL \| EXEC_DIR_IGNORE_ERRORS);
364	assert_se(r >= 0);	1✔
365
366	STRV_FOREACH(p, env)	5✔
367	log_info("got env: \"%s\"", *p);	4✔
368
369	ASSERT_STREQ(strv_env_get(env, "A"), "22:23:24");	1✔
370	ASSERT_STREQ(strv_env_get(env, "B"), "12");	1✔
371	ASSERT_STREQ(strv_env_get(env, "C"), "001");	1✔
372	ASSERT_STREQ(strv_env_get(env, "PATH"), DEFAULT_PATH_WITHOUT_SBIN ":/no/such/file");	1✔
373
374	/* reset environ PATH */
375	assert_se(set_unset_env("PATH", old, true) == 0);	1✔
376	}
377
378	TEST(error_catching) {	1✔
379	_cleanup_(rm_rf_physical_and_freep) char *tmpdir = NULL;	×
380	const char name, name2, *name3;	1✔
381	int r;	1✔
382
383	assert_se(mkdtemp_malloc("/tmp/test-exec-util.XXXXXXX", &tmpdir) >= 0);	1✔
384
385	const char *dirs[] = { tmpdir, NULL };	1✔
386
387	/* write files */
388	name = strjoina(tmpdir, "/10-foo");	5✔
389	name2 = strjoina(tmpdir, "/20-bar");	5✔
390	name3 = strjoina(tmpdir, "/30-last");	5✔
391
392	assert_se(write_string_file(name,	1✔
393	"#!/bin/sh\necho a\necho b\necho c\n",
394	WRITE_STRING_FILE_CREATE) == 0);
395	assert_se(write_string_file(name2,	1✔
396	"#!/bin/sh\nexit 42\n",
397	WRITE_STRING_FILE_CREATE) == 0);
398	assert_se(write_string_file(name3,	1✔
399	"#!/bin/sh\nexit 12",
400	WRITE_STRING_FILE_CREATE) == 0);
401
402	assert_se(chmod(name, 0755) == 0);	1✔
403	assert_se(chmod(name2, 0755) == 0);	1✔
404	assert_se(chmod(name3, 0755) == 0);	1✔
405
406	if (access(name, X_OK) < 0 && ERRNO_IS_PRIVILEGE(errno))	1✔
407	return;	×
408
409	r = execute_directories(__func__,	1✔
410	dirs, DEFAULT_TIMEOUT_USEC,
411	/* callbacks = / NULL, / callback_args = */ NULL,
412	/* argv = / NULL, / envp = / NULL, / flags = */ 0);
413
414	/* we should exit with the error code of the first script that failed */
415	assert_se(r == 42);	1✔
416	}
417
418	TEST(exec_command_flags_from_strv) {	1✔
419	ExecCommandFlags flags = 0;	1✔
420	char **valid_strv = STRV_MAKE("no-env-expand", "no-setuid", "ignore-failure");	1✔
421	char **invalid_strv = STRV_MAKE("no-env-expand", "no-setuid", "nonexistent-option", "ignore-failure");	1✔
422	int r;	1✔
423
424	r = exec_command_flags_from_strv(valid_strv, &flags);	1✔
425
426	assert_se(r == 0);	1✔
427	assert_se(FLAGS_SET(flags, EXEC_COMMAND_NO_ENV_EXPAND));	1✔
428	assert_se(FLAGS_SET(flags, EXEC_COMMAND_NO_SETUID));	1✔
429	assert_se(FLAGS_SET(flags, EXEC_COMMAND_IGNORE_FAILURE));	1✔
430	assert_se(!FLAGS_SET(flags, EXEC_COMMAND_FULLY_PRIVILEGED));	1✔
431
432	r = exec_command_flags_from_strv(invalid_strv, &flags);	1✔
433
434	assert_se(r == -EINVAL);	1✔
435	}	1✔
436
437	TEST(exec_command_flags_to_strv) {	1✔
438	_cleanup_strv_free_ char **opts = NULL;	×
439
440	ASSERT_OK(exec_command_flags_to_strv(EXEC_COMMAND_NO_ENV_EXPAND\|EXEC_COMMAND_IGNORE_FAILURE, &opts));	1✔
441	assert_se(strv_equal(opts, STRV_MAKE("ignore-failure", "no-env-expand")));	1✔
442
443	opts = strv_free(opts);	1✔
444
445	ASSERT_OK(exec_command_flags_to_strv(0, &opts));	1✔
446	assert_se(strv_isempty(opts));	1✔
447
448	opts = strv_free(opts);	1✔
449
450	ASSERT_ERROR(exec_command_flags_to_strv(1U << 20, &opts), EINVAL);	1✔
451	}	1✔
452
453	DEFINE_TEST_MAIN(LOG_DEBUG);	1✔

systemd / systemd / 19315930715

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous