HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/test/test-process-util.c
Git blob: ee8dc29526b594908a744006fb9ef7786b08565d
Lines 1001–1185 of 1,185
"(subreaper)",
FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_REOPEN_LOG|FORK_WAIT,
NULL));
if (r == 0) {
/* child */
ASSERT_OK(make_reaper_process(true));
ASSERT_OK_POSITIVE(is_reaper_process());
_exit(EXIT_SUCCESS);
}
}
TEST(pid_get_start_time) {
_cleanup_(pidref_done) PidRef pidref = PIDREF_NULL;
ASSERT_OK(pidref_set_self(&pidref));
usec_t start_time;
ASSERT_OK(pidref_get_start_time(&pidref, &start_time));
log_info("our starttime: " USEC_FMT, start_time);
_cleanup_(pidref_done_sigkill_wait) PidRef child = PIDREF_NULL;
ASSERT_OK_POSITIVE(pidref_safe_fork("(stub)", FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_REOPEN_LOG|FORK_FREEZE, &child));
usec_t start_time2;
ASSERT_OK(pidref_get_start_time(&child, &start_time2));
log_info("child starttime: " USEC_FMT, start_time2);
ASSERT_GE(start_time2, start_time);
}
TEST(pidref_from_same_root_fs) {
int r;
_cleanup_(pidref_done) PidRef pid1 = PIDREF_NULL, self = PIDREF_NULL;
ASSERT_OK(pidref_set_self(&self));
ASSERT_OK(pidref_set_pid(&pid1, 1));
ASSERT_OK_POSITIVE(pidref_from_same_root_fs(&self, &self));
ASSERT_OK_POSITIVE(pidref_from_same_root_fs(&pid1, &pid1));
r = pidref_from_same_root_fs(&pid1, &self);
if (ERRNO_IS_NEG_PRIVILEGE(r))
return (void) log_tests_skipped("skipping pidref_from_same_root_fs() test, lacking privileged.");
ASSERT_OK(r);
log_info("PID1 and us have the same rootfs: %s", yes_no(r));
int q = pidref_from_same_root_fs(&self, &pid1);
ASSERT_OK(q);
ASSERT_EQ(r, q);
_cleanup_(pidref_done_sigkill_wait) PidRef child1 = PIDREF_NULL;
ASSERT_OK(pidref_safe_fork("(child1)", FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_REOPEN_LOG|FORK_FREEZE, &child1));
ASSERT_OK_POSITIVE(pidref_from_same_root_fs(&self, &child1));
_cleanup_close_ int efd = eventfd(0, EFD_CLOEXEC);
ASSERT_OK_ERRNO(efd);
_cleanup_(pidref_done_sigkill_wait) PidRef child2 = PIDREF_NULL;
r = pidref_safe_fork("(child2)", FORK_RESET_SIGNALS|FORK_REOPEN_LOG, &child2);
ASSERT_OK(r);
if (r == 0) {
ASSERT_OK_ERRNO(chroot("/usr"));
uint64_t u = 1;
ASSERT_OK_EQ_ERRNO(write(efd, &u, sizeof(u)), (ssize_t) sizeof(u));
freeze();
}
uint64_t u;
ASSERT_OK_EQ_ERRNO(read(efd, &u, sizeof(u)), (ssize_t) sizeof(u));
ASSERT_OK_ZERO(pidref_from_same_root_fs(&self, &child2));
ASSERT_OK_ZERO(pidref_from_same_root_fs(&child2, &self));
}
TEST(getenv_for_pid) {
_cleanup_strv_free_ char **copy_env = NULL;
pid_t pid = getpid_cached();
int r;
ASSERT_NOT_NULL(copy_env = strv_copy(environ));
ASSERT_OK(r = pidref_safe_fork("(getenv_for_pid)", FORK_WAIT, NULL));
if (r == 0) {
STRV_FOREACH(e, copy_env) {
const char *v = strchr(*e, '=');
if (!v)
continue;
_cleanup_free_ char *k = NULL;
ASSERT_NOT_NULL(k = strndup(*e, v - *e));
v++;
_cleanup_free_ char *value = NULL;
ASSERT_OK_POSITIVE(getenv_for_pid(pid, k, &value));
ASSERT_STREQ(value, v);
}
if (!strv_find_startswith(copy_env, "HOGEHOGE")) {
char *value = POINTER_MAX;
ASSERT_OK_ZERO(getenv_for_pid(pid, "HOGEHOGE", &value));
ASSERT_NULL(value);
}
_exit(EXIT_SUCCESS);
}
}
TEST(invoked_as) {
ASSERT_FALSE(invoked_as(NULL, "foobar"));
ASSERT_FALSE(invoked_as(NULL, "barbar"));
ASSERT_EQ(setenv("SYSTEMD_INVOKED_AS", "/usr/bin/foobar", 1), 0);
ASSERT_TRUE(invoked_as(NULL, "foobar"));
ASSERT_FALSE(invoked_as(NULL, "barbar"));
ASSERT_TRUE(invoked_as(NULL, "foo"));
ASSERT_TRUE(invoked_as(STRV_MAKE("barbar", "barbar", "y"), "foobar"));
ASSERT_FALSE(invoked_as(STRV_MAKE("barbar", "barbar", "y"), "barbar"));
ASSERT_EQ(unsetenv("SYSTEMD_INVOKED_AS"), 0);
}
#define EXIT_EXPECTED_ERROR 42
static void test_execvp_safe_one(const char *name, const char *search_path, int expected_error) {
_cleanup_(pidref_done) PidRef pidref = PIDREF_NULL;
int r;
/* If expected_error is 0, the binary is expected to be executed and to exit successfully. Otherwise
* execvp_safe() is expected to return expected_error. */
r = ASSERT_OK(pidref_safe_fork("(execvp-safe)", FORK_DEATHSIG_SIGKILL|FORK_LOG, &pidref));
if (r == 0) {
if (search_path && setenv("PATH", search_path, /* overwrite= */ true) < 0) {
log_error_errno(errno, "Failed to set $PATH: %m");
_exit(EXIT_FAILURE);
}
r = execvp_safe(name, STRV_MAKE(name));
if (r != expected_error) {
log_error_errno(r, "execvp_safe(\"%s\") returned unexpected error: %m", name);
_exit(EXIT_FAILURE);
}
_exit(EXIT_EXPECTED_ERROR);
}
int expected_exit_status = expected_error == 0 ? EXIT_SUCCESS : EXIT_EXPECTED_ERROR;
ASSERT_OK_EQ(pidref_wait_for_terminate_and_check("(execvp-safe)", &pidref, WAIT_LOG_ABNORMAL),
expected_exit_status);
}
TEST(execvp_safe) {
_cleanup_(rm_rf_physical_and_freep) char *d = NULL;
_cleanup_free_ char *p = NULL;
/* An empty executable file must make execvp_safe() fail with ENOEXEC, and must not be run as an
* empty shell script, which would exit successfully. */
ASSERT_OK(mkdtemp_malloc(NULL, &d));
ASSERT_NOT_NULL(p = path_join(d, "test-process-util-empty"));
ASSERT_OK(touch_file(p, /* parents= */ false, USEC_INFINITY, UID_INVALID, GID_INVALID, 0755));
if (access(p, X_OK) < 0) /* e.g. /tmp/ mounted noexec */
return (void) log_tests_skipped_errno(errno, "Cannot execute files in %s", d);
test_execvp_safe_one(p, /* search_path= */ NULL, -ENOEXEC);
test_execvp_safe_one("test-process-util-empty", d, -ENOEXEC);
test_execvp_safe_one("test-process-util-missing", d, -ENOENT);
test_execvp_safe_one("true", /* search_path= */ NULL, 0);
}
static int intro(void) {
log_show_color(true);
return EXIT_SUCCESS;
}
DEFINE_TEST_MAIN_WITH_INTRO(LOG_INFO, intro);