HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/test/test-process-util.c

45,066 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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);