feat(process): fork/exec/id/session + system/popen
This commit is contained in:
@@ -0,0 +1,779 @@
|
||||
/*
|
||||
* vlibc — process control test (todo 20).
|
||||
*
|
||||
* Exercises fork/vfork/exec family/ids/session + system/popen end to
|
||||
* end:
|
||||
*
|
||||
* 1. getpid/getppid/getuid/geteuid/getgid/getegid return live values.
|
||||
* 2. fork: the child writes a marker and its pid through a pipe and
|
||||
* exits 7 via the raw syscall; the parent sees 0 + the pid round
|
||||
* trip and reaps a 7<<8 status via raw SYS_wait4.
|
||||
* 3. fork + execve("/bin/true") exits 0.
|
||||
* 4. fork + execve of a nonexistent binary: the child exits 127, the
|
||||
* parent reaps 127<<8.
|
||||
* 5. system("exit 3") returns 768 (WEXITSTATUS 3).
|
||||
* 6. popen("echo hi","r") reads "hi\n" and pclose returns 0;
|
||||
* popen("cat","w") writes through and pclose returns 0.
|
||||
* 7. setuid(getuid()) etc. round trip to 0; getgroups counts and
|
||||
* fills consistently.
|
||||
* 8. (L2) session control in fork children: setsid/getpgrp/getsid and
|
||||
* setpgid/setpgrp/getpgid; tcgetpgrp/tcsetpgrp fail with -1 on a
|
||||
* pipe (ENOTTY, no errno read).
|
||||
* 9. one fork+exec each for execl/execlp/execv/execvp/execle/fexecve.
|
||||
* 10. PATH search: a helper script in a private directory is found via
|
||||
* a custom PATH (exit 5 → 5<<8), an empty PATH entry means cwd,
|
||||
* and execvp falls back to the default PATH when environ is NULL.
|
||||
* 11. (L2) vfork: the child execs /bin/true, the parent reaps 0.
|
||||
*
|
||||
* sys/wait.h is todo 23 and does not exist: the test waits via raw
|
||||
* SYS_wait4 in its own helper, and children exit via the raw syscalls.
|
||||
*
|
||||
* The negative paths make the LIBRARY write errno (syscall_ret), which
|
||||
* under a host-linked binary targets glibc's private dtv slot at
|
||||
* %fs:0+8. In the default mode each such call is bracketed with a
|
||||
* save/restore of that slot (task 13 technique) — only vlibc/raw-syscall
|
||||
* code runs between the write and the restore, so host state is intact
|
||||
* when host code runs again. The test itself NEVER reads errno; every
|
||||
* negative is asserted on the return value. The -f mode runs the
|
||||
* failure scenarios and exits via raw SYS_exit_group (house pattern,
|
||||
* tests/test_malloc.c).
|
||||
*
|
||||
* All diagnostics go through raw SYS_write (no host stdio): under
|
||||
* -Iinclude the vlibc public headers shadow GCC's internal ones, so a
|
||||
* host header would not compile. Only vlibc headers are included.
|
||||
*/
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
#include "../include/stdio.h"
|
||||
#include "../include/stdlib.h"
|
||||
#include "../include/unistd.h"
|
||||
|
||||
#include "../src/internal/syscall.h"
|
||||
|
||||
/* Kernel-UAPI constants local to this test (fcntl.h is todo 21). */
|
||||
#define T20_O_RDONLY 0x0
|
||||
#define T20_O_WRONLY 0x1
|
||||
#define T20_O_CREAT 0x40
|
||||
#define T20_O_TRUNC 0x200
|
||||
#define T20_AT_FDCWD (-100)
|
||||
#define T20_EINTR 4
|
||||
|
||||
static int failures;
|
||||
|
||||
/* Write a NUL-terminated string to fd via the raw syscall layer. The
|
||||
* optimize attribute keeps GCC from lowering the length loop into a
|
||||
* strlen call, which would leave a vlibc-owned symbol undefined in this
|
||||
* host-linked standalone binary (house idiom, see src/string). */
|
||||
static __attribute__((optimize("no-tree-loop-distribute-patterns"))) void
|
||||
say(int fd, const char *s)
|
||||
{
|
||||
long n = 0;
|
||||
|
||||
while (s[n] != '\0')
|
||||
{
|
||||
n++;
|
||||
}
|
||||
__syscall3(SYS_write, fd, (long)s, n);
|
||||
}
|
||||
|
||||
/* Write v in decimal to fd. */
|
||||
static void
|
||||
say_dec(int fd, unsigned long v) // NOLINT(bugprone-easily-swappable-parameters)
|
||||
{
|
||||
char buf[24];
|
||||
int i = (int)sizeof(buf);
|
||||
|
||||
buf[--i] = '\0';
|
||||
do
|
||||
{
|
||||
buf[--i] = (char)('0' + (v % 10));
|
||||
v /= 10;
|
||||
} while (v != 0);
|
||||
__syscall3(SYS_write, fd, (long)(buf + i), (long)(sizeof(buf) - 1 - i));
|
||||
}
|
||||
|
||||
static void
|
||||
check(int cond, const char *what)
|
||||
{
|
||||
if (cond)
|
||||
{
|
||||
say(1, "PASS: ");
|
||||
say(1, what);
|
||||
say(1, "\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
say(2, "FAIL: ");
|
||||
say(2, what);
|
||||
say(2, "\n");
|
||||
failures++;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Host-TCB slot-1 bracket: the library's errno write on a negative path
|
||||
* lands at %fs:0+8, glibc's dtv pointer. Save and restore it around each
|
||||
* such call; only vlibc/raw-syscall code runs in between (task 13
|
||||
* technique).
|
||||
*/
|
||||
static unsigned long
|
||||
tcb_slot1(void)
|
||||
{
|
||||
return *(unsigned long *)((char *)__builtin_thread_pointer() + 8);
|
||||
}
|
||||
|
||||
static void
|
||||
tcb_slot1_set(unsigned long value)
|
||||
{
|
||||
*(unsigned long *)((char *)__builtin_thread_pointer() + 8) = value;
|
||||
}
|
||||
|
||||
/* Wait for pid via the raw syscall (sys/wait.h is todo 23) and return
|
||||
* the raw wait status, or -1 when wait4 failed for a reason other than
|
||||
* EINTR. */
|
||||
static int
|
||||
raw_wait(pid_t pid)
|
||||
{
|
||||
int status = 0;
|
||||
|
||||
for (;;)
|
||||
{
|
||||
long r = __syscall4(SYS_wait4, pid, (long)&status, 0, 0);
|
||||
|
||||
if (r < 0 && -r == T20_EINTR)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
if (r < 0)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
return status;
|
||||
}
|
||||
}
|
||||
|
||||
/* Run fn(argv) in a fork child (via a public exec entry point) and
|
||||
* return the child's wait status; the child exits 127 through the raw
|
||||
* syscall when the exec entry point returns. */
|
||||
typedef int (*t20_exec_fn)(void);
|
||||
|
||||
static int
|
||||
exec_one(const char *label, t20_exec_fn fn)
|
||||
{
|
||||
pid_t pid = fork();
|
||||
int status;
|
||||
|
||||
if (pid < 0)
|
||||
{
|
||||
check(0, label);
|
||||
return -1;
|
||||
}
|
||||
if (pid == 0)
|
||||
{
|
||||
/* Child: exec (or raw-exit 127 on failure). */
|
||||
(void)fn();
|
||||
__syscall1(SYS_exit_group, 127);
|
||||
}
|
||||
status = raw_wait(pid);
|
||||
check(status == 0, label);
|
||||
return status;
|
||||
}
|
||||
|
||||
/* The per-entry-point payloads. Each runs in the fork child. */
|
||||
static char *av_true[] = {"true", 0};
|
||||
static char *env_le[] = {"VLIBC_T20=le", 0};
|
||||
static char *env_ve[] = {"VLIBC_T20=ve", 0};
|
||||
|
||||
static int
|
||||
run_execve(void)
|
||||
{
|
||||
static char *envp_ok[] = {"VLIBC_T20=yes", 0};
|
||||
|
||||
return execve("/bin/true", av_true, envp_ok);
|
||||
}
|
||||
|
||||
static int
|
||||
run_fexecve(void)
|
||||
{
|
||||
int fd = open("/bin/true", T20_O_RDONLY);
|
||||
|
||||
if (fd < 0)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
return fexecve(fd, av_true, environ);
|
||||
}
|
||||
|
||||
/* 1. Process ids. */
|
||||
static void
|
||||
id_scenarios(void)
|
||||
{
|
||||
check(getpid() > 0, "getpid returns a positive pid");
|
||||
check(getppid() > 0, "getppid returns a positive pid");
|
||||
check(getuid() == geteuid(), "getuid and geteuid agree");
|
||||
check(getgid() == getegid(), "getgid and getegid agree");
|
||||
}
|
||||
|
||||
/* 2. fork: marker + pid round trip through a pipe, child exits 7. */
|
||||
static void
|
||||
fork_scenario(void)
|
||||
{
|
||||
int fds[2] = {0};
|
||||
unsigned char buf[5] = {0}; /* filled by SYS_read; the analyzer cannot model it */
|
||||
pid_t pid;
|
||||
int status;
|
||||
|
||||
if (syscall_ret(__syscall1(SYS_pipe, (long)fds)) < 0)
|
||||
{
|
||||
check(0, "fork scenario pipe");
|
||||
return;
|
||||
}
|
||||
pid = fork();
|
||||
if (pid < 0)
|
||||
{
|
||||
check(0, "fork returns a pid");
|
||||
check(0, "child writes the marker and its pid");
|
||||
check(0, "parent reaps the child with status 7<<8");
|
||||
(void)__syscall1(SYS_close, fds[0]);
|
||||
(void)__syscall1(SYS_close, fds[1]);
|
||||
return;
|
||||
}
|
||||
if (pid == 0)
|
||||
{
|
||||
int mypid = getpid();
|
||||
|
||||
/* Child: marker + pid, then exit 7 via the raw syscall. */
|
||||
buf[0] = 'c';
|
||||
buf[1] = (unsigned char)(mypid & 0xff);
|
||||
buf[2] = (unsigned char)((mypid >> 8) & 0xff);
|
||||
buf[3] = (unsigned char)((mypid >> 16) & 0xff);
|
||||
buf[4] = (unsigned char)((mypid >> 24) & 0xff);
|
||||
(void)__syscall3(SYS_write, fds[1], (long)buf, 5);
|
||||
__syscall1(SYS_exit_group, 7);
|
||||
}
|
||||
check(pid > 0, "fork returns the child pid in the parent");
|
||||
check(__syscall3(SYS_read, fds[0], (long)buf, 5) == 5, "parent reads the five marker bytes");
|
||||
{
|
||||
int child_pid = (int)((unsigned int)buf[1] | ((unsigned int)buf[2] << 8) |
|
||||
((unsigned int)buf[3] << 16) | ((unsigned int)buf[4] << 24));
|
||||
|
||||
check(buf[0] == 'c' && child_pid == pid,
|
||||
"the child's getpid matches the parent's fork return value");
|
||||
}
|
||||
(void)__syscall1(SYS_close, fds[0]);
|
||||
(void)__syscall1(SYS_close, fds[1]);
|
||||
status = raw_wait(pid);
|
||||
check(status == 7 << 8, "the child exited 7 (status 7<<8 == 1792)");
|
||||
}
|
||||
|
||||
/* 3+4. execve of a good and of a nonexistent binary. */
|
||||
static void
|
||||
exec_scenarios(void)
|
||||
{
|
||||
pid_t pid;
|
||||
int status;
|
||||
|
||||
pid = fork();
|
||||
if (pid < 0)
|
||||
{
|
||||
check(0, "execve /bin/true child exits 0");
|
||||
return;
|
||||
}
|
||||
if (pid == 0)
|
||||
{
|
||||
(void)run_execve();
|
||||
__syscall1(SYS_exit_group, 127);
|
||||
}
|
||||
status = raw_wait(pid);
|
||||
check(status == 0, "fork + execve(\"/bin/true\") exits 0");
|
||||
|
||||
pid = fork();
|
||||
if (pid < 0)
|
||||
{
|
||||
check(0, "execve of a nonexistent binary gives 127<<8");
|
||||
return;
|
||||
}
|
||||
if (pid == 0)
|
||||
{
|
||||
static char *av_bad[] = {"vlibc-no-such-binary", 0};
|
||||
|
||||
(void)execve("/bin/nonexistent-vlibc-xyz", av_bad, environ);
|
||||
__syscall1(SYS_exit_group, 127);
|
||||
}
|
||||
status = raw_wait(pid);
|
||||
check(status == 127 << 8, "failed execve: the child exited 127 (status 127<<8)");
|
||||
}
|
||||
|
||||
/* 5. system. */
|
||||
// NOLINTBEGIN(bugprone-command-processor)
|
||||
static void
|
||||
system_scenario(void)
|
||||
{
|
||||
check(system("exit 3") == 768, "system(\"exit 3\") returns 768 (WEXITSTATUS 3)");
|
||||
}
|
||||
// NOLINTEND(bugprone-command-processor)
|
||||
|
||||
/* 6. popen/pclose. */
|
||||
// NOLINTBEGIN(bugprone-command-processor)
|
||||
static void
|
||||
popen_scenario(void)
|
||||
{
|
||||
FILE *f;
|
||||
char rbuf[8];
|
||||
long n = 0;
|
||||
int rc;
|
||||
|
||||
f = popen("echo hi", "r");
|
||||
check(f != 0, "popen(\"echo hi\", \"r\") returns a stream");
|
||||
if (f == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
n = (long)fread(rbuf, 1, sizeof(rbuf), f);
|
||||
check(n == 3, "fread on the popen stream returns three bytes");
|
||||
n = 0;
|
||||
while (n < 3 && rbuf[n] == "hi\n"[n])
|
||||
{
|
||||
n++;
|
||||
}
|
||||
check(n == 3, "the stream reads \"hi\\n\"");
|
||||
rc = pclose(f);
|
||||
check(rc == 0, "pclose of the \"r\" stream returns 0");
|
||||
|
||||
f = popen("cat >/dev/null", "w");
|
||||
check(f != 0, "popen(\"cat >/dev/null\", \"w\") returns a stream");
|
||||
if (f == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
check(fwrite("bye", 1, 3, f) == 3, "three bytes are written to the \"w\" stream");
|
||||
rc = pclose(f);
|
||||
check(rc == 0, "pclose of the \"w\" stream returns 0");
|
||||
}
|
||||
// NOLINTEND(bugprone-command-processor)
|
||||
|
||||
/* 7. uid/gid round trip + supplementary groups. */
|
||||
static void
|
||||
uid_scenarios(void)
|
||||
{
|
||||
gid_t gids[64];
|
||||
int n;
|
||||
int m;
|
||||
|
||||
check(setuid(getuid()) == 0, "setuid(getuid()) returns 0");
|
||||
check(seteuid(geteuid()) == 0, "seteuid(geteuid()) returns 0");
|
||||
check(setgid(getgid()) == 0, "setgid(getgid()) returns 0");
|
||||
check(setegid(getegid()) == 0, "setegid(getegid()) returns 0");
|
||||
n = getgroups(0, 0);
|
||||
check(n >= 0, "getgroups(0, NULL) returns a non-negative count");
|
||||
if (n >= 0)
|
||||
{
|
||||
m = getgroups(64, gids);
|
||||
check(m == n, "getgroups(64, list) returns the same count");
|
||||
}
|
||||
}
|
||||
|
||||
#if VLIBC_LEVEL_GE(2)
|
||||
|
||||
/* 8. Session control in fork children (never in the parent: leaving the
|
||||
* parent's process group would trigger SIGTTOU on terminal writes). */
|
||||
static void
|
||||
session_scenarios(void)
|
||||
{
|
||||
int fds[2] = {0};
|
||||
pid_t pid;
|
||||
int status;
|
||||
unsigned long saved;
|
||||
|
||||
/* Child A: setsid makes it a session and group leader. */
|
||||
pid = fork();
|
||||
if (pid < 0)
|
||||
{
|
||||
check(0, "setsid child");
|
||||
return;
|
||||
}
|
||||
if (pid == 0)
|
||||
{
|
||||
pid_t sid = setsid();
|
||||
|
||||
if (sid != getpid())
|
||||
{
|
||||
__syscall1(SYS_exit_group, 1);
|
||||
}
|
||||
if (getpgrp() != getpid())
|
||||
{
|
||||
__syscall1(SYS_exit_group, 2);
|
||||
}
|
||||
if (getsid(0) != getpid())
|
||||
{
|
||||
__syscall1(SYS_exit_group, 3);
|
||||
}
|
||||
__syscall1(SYS_exit_group, 0);
|
||||
}
|
||||
status = raw_wait(pid);
|
||||
check(status == 0, "child: setsid() == getpid(), getpgrp() == pid, getsid(0) == pid");
|
||||
|
||||
/* Child B: setpgid(0,0) + setpgrp() + getpgid. */
|
||||
pid = fork();
|
||||
if (pid < 0)
|
||||
{
|
||||
check(0, "setpgid child");
|
||||
return;
|
||||
}
|
||||
if (pid == 0)
|
||||
{
|
||||
if (setpgid(0, 0) != 0)
|
||||
{
|
||||
__syscall1(SYS_exit_group, 1);
|
||||
}
|
||||
if (setpgrp() != 0)
|
||||
{
|
||||
__syscall1(SYS_exit_group, 2);
|
||||
}
|
||||
if (getpgrp() != getpid())
|
||||
{
|
||||
__syscall1(SYS_exit_group, 3);
|
||||
}
|
||||
if (getpgid(0) != getpid())
|
||||
{
|
||||
__syscall1(SYS_exit_group, 4);
|
||||
}
|
||||
__syscall1(SYS_exit_group, 0);
|
||||
}
|
||||
status = raw_wait(pid);
|
||||
check(status == 0, "child: setpgid(0,0), setpgrp(), getpgrp(), getpgid(0) all agree");
|
||||
|
||||
/* tcgetpgrp/tcsetpgrp on a pipe fail with -1 (ENOTTY). */
|
||||
if (syscall_ret(__syscall1(SYS_pipe, (long)fds)) < 0)
|
||||
{
|
||||
check(0, "tcgetpgrp on a pipe");
|
||||
check(0, "tcsetpgrp on a pipe");
|
||||
return;
|
||||
}
|
||||
saved = tcb_slot1();
|
||||
check(tcgetpgrp(fds[0]) == (pid_t)-1, "tcgetpgrp on a pipe returns -1");
|
||||
tcb_slot1_set(saved);
|
||||
saved = tcb_slot1();
|
||||
check(tcsetpgrp(fds[0], 0) == -1, "tcsetpgrp on a pipe returns -1");
|
||||
tcb_slot1_set(saved);
|
||||
(void)__syscall1(SYS_close, fds[0]);
|
||||
(void)__syscall1(SYS_close, fds[1]);
|
||||
}
|
||||
|
||||
/* 11. vfork: the child execs /bin/true while the parent is suspended. */
|
||||
// NOLINTBEGIN(clang-analyzer-security.insecureAPI.vfork, clang-analyzer-unix.Vfork,
|
||||
// bugprone-unsafe-functions)
|
||||
static void
|
||||
vfork_scenario(void)
|
||||
{
|
||||
pid_t pid = vfork();
|
||||
int status;
|
||||
|
||||
if (pid == 0)
|
||||
{
|
||||
/* Child: exec (the only sanctioned follow-up) or raw-exit. */
|
||||
(void)execve("/bin/true", av_true, environ);
|
||||
__syscall1(SYS_exit_group, 126);
|
||||
}
|
||||
check(pid >= 0, "vfork returns a pid in the parent (0 in the child)");
|
||||
if (pid < 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
status = raw_wait(pid);
|
||||
check(status == 0, "vfork child exec'd /bin/true and exited 0");
|
||||
}
|
||||
// NOLINTEND(clang-analyzer-security.insecureAPI.vfork, clang-analyzer-unix.Vfork,
|
||||
// bugprone-unsafe-functions)
|
||||
|
||||
#endif /* VLIBC_LEVEL_GE(2) */
|
||||
|
||||
/* 9. One fork+exec per entry point. */
|
||||
static int
|
||||
run_execv(void)
|
||||
{
|
||||
return execv("/bin/true", av_true);
|
||||
}
|
||||
|
||||
static int
|
||||
run_execvp(void)
|
||||
{
|
||||
return execvp("true", av_true);
|
||||
}
|
||||
|
||||
static int
|
||||
run_execl(void)
|
||||
{
|
||||
return execl("/bin/true", "true", (char *)0);
|
||||
}
|
||||
|
||||
static int
|
||||
run_execlp(void)
|
||||
{
|
||||
return execlp("true", "true", (char *)0);
|
||||
}
|
||||
|
||||
static int
|
||||
run_execle(void)
|
||||
{
|
||||
return execle("/bin/true", "true", (char *)0, env_le);
|
||||
}
|
||||
|
||||
static void
|
||||
exec_variants(void)
|
||||
{
|
||||
(void)exec_one("execv(\"/bin/true\")", run_execv);
|
||||
(void)exec_one("execvp(\"true\") via the default PATH", run_execvp);
|
||||
(void)exec_one("execl(\"/bin/true\")", run_execl);
|
||||
(void)exec_one("execlp(\"true\") via the default PATH", run_execlp);
|
||||
(void)exec_one("execle(\"/bin/true\") with a custom envp", run_execle);
|
||||
(void)exec_one("fexecve of an open /bin/true", run_fexecve);
|
||||
}
|
||||
|
||||
/* 10. PATH search with a private helper script. */
|
||||
static void
|
||||
path_search_scenario(void)
|
||||
{
|
||||
const char *dir = "/tmp/vlibc-t20-bin";
|
||||
const char *script_path = "/tmp/vlibc-t20-bin/vlibc-t20-helper";
|
||||
const char script[] = "#!/bin/sh\nexit 5\n";
|
||||
static char *path_env[] = {"PATH=/tmp/vlibc-t20-bin", 0};
|
||||
static char *path_env_cwd[] = {"PATH=:/tmp/vlibc-t20-bin", 0};
|
||||
char **saved_environ;
|
||||
unsigned long saved;
|
||||
int fd;
|
||||
|
||||
(void)__syscall2(SYS_mkdir, (long)dir, 0755); /* EEXIST is fine */
|
||||
fd = open(script_path, T20_O_WRONLY | T20_O_CREAT | T20_O_TRUNC, 0755);
|
||||
check(fd >= 0, "the helper script is created");
|
||||
if (fd >= 0)
|
||||
{
|
||||
check(write(fd, script, sizeof(script) - 1) == (ssize_t)(sizeof(script) - 1),
|
||||
"the helper script body is written");
|
||||
check(close(fd) == 0, "the helper script descriptor is closed");
|
||||
}
|
||||
|
||||
saved_environ = environ;
|
||||
environ = path_env;
|
||||
{
|
||||
pid_t pid = fork();
|
||||
int status;
|
||||
|
||||
if (pid < 0)
|
||||
{
|
||||
check(0, "execvp finds the helper via the custom PATH");
|
||||
environ = saved_environ;
|
||||
return;
|
||||
}
|
||||
if (pid == 0)
|
||||
{
|
||||
static char *av[] = {"vlibc-t20-helper", 0};
|
||||
|
||||
(void)execvp("vlibc-t20-helper", av);
|
||||
__syscall1(SYS_exit_group, 127);
|
||||
}
|
||||
status = raw_wait(pid);
|
||||
check(status == 5 << 8, "execvp finds the helper via PATH and it exits 5");
|
||||
}
|
||||
{
|
||||
pid_t pid = fork();
|
||||
int status;
|
||||
|
||||
if (pid < 0)
|
||||
{
|
||||
check(0, "execlp finds the helper via the custom PATH");
|
||||
environ = saved_environ;
|
||||
return;
|
||||
}
|
||||
if (pid == 0)
|
||||
{
|
||||
(void)execlp("vlibc-t20-helper", "vlibc-t20-helper", (char *)0);
|
||||
__syscall1(SYS_exit_group, 127);
|
||||
}
|
||||
status = raw_wait(pid);
|
||||
check(status == 5 << 8, "execlp finds the helper via PATH and it exits 5");
|
||||
}
|
||||
|
||||
/* An empty PATH entry means the current directory (skipped here:
|
||||
* the helper is not in cwd), and the search still reaches the
|
||||
* second entry. */
|
||||
environ = path_env_cwd;
|
||||
{
|
||||
pid_t pid = fork();
|
||||
int status;
|
||||
|
||||
if (pid < 0)
|
||||
{
|
||||
check(0, "empty PATH entry is skipped");
|
||||
environ = saved_environ;
|
||||
return;
|
||||
}
|
||||
if (pid == 0)
|
||||
{
|
||||
static char *av[] = {"vlibc-t20-helper", 0};
|
||||
|
||||
(void)execvp("vlibc-t20-helper", av);
|
||||
__syscall1(SYS_exit_group, 127);
|
||||
}
|
||||
status = raw_wait(pid);
|
||||
check(status == 5 << 8, "an empty PATH entry means cwd and the search continues");
|
||||
}
|
||||
|
||||
/* environ NULL -> the built-in default PATH finds /bin/true. */
|
||||
environ = 0;
|
||||
(void)exec_one("execvp(\"true\") with environ NULL (default PATH)", run_execvp);
|
||||
|
||||
/* Not found anywhere: -1 (errno written, bracketed). */
|
||||
saved = tcb_slot1();
|
||||
check(execvp("vlibc-no-such-helper-xyz", av_true) == -1,
|
||||
"execvp of a missing helper returns -1");
|
||||
tcb_slot1_set(saved);
|
||||
|
||||
environ = saved_environ;
|
||||
(void)__syscall3(SYS_unlinkat, T20_AT_FDCWD, (long)script_path, 0);
|
||||
(void)__syscall1(SYS_rmdir, (long)dir);
|
||||
}
|
||||
|
||||
/*
|
||||
* Failure scenarios (-f): every assertion is on the return value only,
|
||||
* and the process exits through raw SYS_exit_group because the library
|
||||
* writes errno on these paths (host-TCB hazard).
|
||||
*/
|
||||
// NOLINTBEGIN(bugprone-command-processor)
|
||||
static int
|
||||
failure_scenarios(void)
|
||||
{
|
||||
unsigned long saved;
|
||||
int rc = 0;
|
||||
|
||||
saved = tcb_slot1();
|
||||
if (execve("/bin/nonexistent-vlibc-xyz", av_true, env_ve) != -1)
|
||||
{
|
||||
say(2, "FAIL: execve of a nonexistent binary did not return -1\n");
|
||||
rc = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
say(1, "PASS: execve of a nonexistent binary -> -1\n");
|
||||
}
|
||||
tcb_slot1_set(saved);
|
||||
|
||||
if (system(0) != 1)
|
||||
{
|
||||
say(2, "FAIL: system(NULL) did not return 1\n");
|
||||
rc = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
say(1, "PASS: system(NULL) -> 1\n");
|
||||
}
|
||||
|
||||
saved = tcb_slot1();
|
||||
if (popen("echo hi", "x") != 0)
|
||||
{
|
||||
say(2, "FAIL: popen with an invalid mode did not return NULL\n");
|
||||
rc = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
say(1, "PASS: popen with an invalid mode -> NULL\n");
|
||||
}
|
||||
tcb_slot1_set(saved);
|
||||
|
||||
saved = tcb_slot1();
|
||||
if (fexecve(-1, av_true, env_ve) != -1)
|
||||
{
|
||||
say(2, "FAIL: fexecve(-1) did not return -1\n");
|
||||
rc = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
say(1, "PASS: fexecve(-1) -> -1\n");
|
||||
}
|
||||
tcb_slot1_set(saved);
|
||||
|
||||
saved = tcb_slot1();
|
||||
if (execvp("", av_true) != -1)
|
||||
{
|
||||
say(2, "FAIL: execvp(\"\") did not return -1\n");
|
||||
rc = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
say(1, "PASS: execvp(\"\") -> -1\n");
|
||||
}
|
||||
tcb_slot1_set(saved);
|
||||
|
||||
saved = tcb_slot1();
|
||||
if (getgroups(-1, 0) != -1)
|
||||
{
|
||||
say(2, "FAIL: getgroups(-1) did not return -1\n");
|
||||
rc = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
say(1, "PASS: getgroups(-1) -> -1\n");
|
||||
}
|
||||
tcb_slot1_set(saved);
|
||||
|
||||
#if VLIBC_LEVEL_GE(2)
|
||||
{
|
||||
gid_t one = 0;
|
||||
|
||||
saved = tcb_slot1();
|
||||
if (setgroups(1, &one) != -1)
|
||||
{
|
||||
say(2, "FAIL: setgroups without privilege did not return -1\n");
|
||||
rc = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
say(1, "PASS: setgroups without privilege -> -1\n");
|
||||
}
|
||||
tcb_slot1_set(saved);
|
||||
}
|
||||
#endif
|
||||
return rc;
|
||||
}
|
||||
// NOLINTEND(bugprone-command-processor)
|
||||
|
||||
int
|
||||
main(int argc, char **argv)
|
||||
{
|
||||
if (argc == 2 && argv[1][0] == '-' && argv[1][1] == 'f')
|
||||
{
|
||||
/*
|
||||
* The failure scenarios write errno inside the library; under
|
||||
* the host libc that slot is glibc's private TLS state, so leave
|
||||
* via the raw syscall without running host cleanup.
|
||||
*/
|
||||
int rc = failure_scenarios();
|
||||
|
||||
__syscall1(SYS_exit_group, rc);
|
||||
return rc; /* not reached */
|
||||
}
|
||||
|
||||
id_scenarios();
|
||||
fork_scenario();
|
||||
exec_scenarios();
|
||||
system_scenario();
|
||||
popen_scenario();
|
||||
uid_scenarios();
|
||||
exec_variants();
|
||||
path_search_scenario();
|
||||
#if VLIBC_LEVEL_GE(2)
|
||||
session_scenarios();
|
||||
vfork_scenario();
|
||||
#endif
|
||||
|
||||
if (failures > 0)
|
||||
{
|
||||
say(2, "FAILED (");
|
||||
say_dec(2, (unsigned long)failures);
|
||||
say(2, " check(s))\n");
|
||||
return 1;
|
||||
}
|
||||
say(1, "all process tests passed\n");
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user