/*
- * A Simple Testing Sandbox
+ * A Simple Sandbox for MO-Eval
*
- * (c) 2001 Martin Mares <mj@ucw.cz>
+ * (c) 2001--2008 Martin Mares <mj@ucw.cz>
*/
#define _LARGEFILE64_SOURCE
#define NONRET __attribute__((noreturn))
#define UNUSED __attribute__((unused))
+#define ARRAY_SIZE(a) (int)(sizeof(a)/sizeof(a[0]))
static int filter_syscalls; /* 0=off, 1=liberal, 2=totalitarian */
-static int timeout;
+static int timeout; /* milliseconds */
+static int wall_timeout;
static int pass_environ;
-static int use_wall_clock;
static int file_access;
static int verbose;
static int memory_limit;
+static char *redir_stdin, *redir_stdout;
+static char *set_cwd;
static pid_t box_pid;
static int is_ptraced;
static volatile int timer_tick;
-static time_t start_time;
+static struct timeval start_time;
static int ticks_per_sec;
+static int exec_seen;
#if defined(__GLIBC__) && __GLIBC__ == 2 && __GLIBC_MINOR__ > 0
/* glibc 2.1 or newer -> has lseek64 */
}
static void __attribute__((format(printf,1,2)))
-log(char *msg, ...)
+msg(char *msg, ...)
{
va_list args;
va_start(args, msg);
va_end(args);
}
+static void *
+xmalloc(size_t size)
+{
+ void *p = malloc(size);
+ if (!p)
+ die("Out of memory");
+ return p;
+}
+
+static const char * const syscall_names[] = {
+#include "syscall-table.h"
+};
+#define NUM_SYSCALLS ARRAY_SIZE(syscall_names)
+#define NUM_ACTIONS (NUM_SYSCALLS+64)
+
+enum action {
+ A_DEFAULT, // Use the default action
+ A_NO, // Always forbid
+ A_YES, // Always permit
+ A_FILENAME, // Permit if arg1 is a known filename
+ A_LIBERAL = 128, // Valid only in liberal mode
+};
+
+static unsigned char syscall_action[NUM_ACTIONS] = {
+#define S(x) [__NR_##x]
+
+ // Syscalls permitted for specific file names
+ S(open) = A_FILENAME,
+ S(creat) = A_FILENAME,
+ S(unlink) = A_FILENAME,
+ S(oldstat) = A_FILENAME,
+ S(access) = A_FILENAME,
+ S(oldlstat) = A_FILENAME,
+ S(truncate) = A_FILENAME,
+ S(stat) = A_FILENAME,
+ S(lstat) = A_FILENAME,
+ S(truncate64) = A_FILENAME,
+ S(stat64) = A_FILENAME,
+ S(lstat64) = A_FILENAME,
+ S(readlink) = A_FILENAME,
+
+ // Syscalls permitted always
+ S(exit) = A_YES,
+ S(read) = A_YES,
+ S(write) = A_YES,
+ S(close) = A_YES,
+ S(lseek) = A_YES,
+ S(getpid) = A_YES,
+ S(getuid) = A_YES,
+ S(oldfstat) = A_YES,
+ S(dup) = A_YES,
+ S(brk) = A_YES,
+ S(getgid) = A_YES,
+ S(geteuid) = A_YES,
+ S(getegid) = A_YES,
+ S(dup2) = A_YES,
+ S(ftruncate) = A_YES,
+ S(fstat) = A_YES,
+ S(personality) = A_YES,
+ S(_llseek) = A_YES,
+ S(readv) = A_YES,
+ S(writev) = A_YES,
+ S(getresuid) = A_YES,
+#ifdef __NR_pread64
+ S(pread64) = A_YES,
+ S(pwrite64) = A_YES,
+#else
+ S(pread) = A_YES,
+ S(pwrite) = A_YES,
+#endif
+ S(ftruncate64) = A_YES,
+ S(fstat64) = A_YES,
+ S(fcntl) = A_YES,
+ S(fcntl64) = A_YES,
+ S(mmap) = A_YES,
+ S(munmap) = A_YES,
+ S(ioctl) = A_YES,
+ S(uname) = A_YES,
+ S(gettid) = A_YES,
+ S(set_thread_area) = A_YES,
+ S(get_thread_area) = A_YES,
+ S(exit_group) = A_YES,
+
+ // Syscalls permitted only in liberal mode
+ S(time) = A_YES | A_LIBERAL,
+ S(alarm) = A_YES | A_LIBERAL,
+ S(pause) = A_YES | A_LIBERAL,
+ S(signal) = A_YES | A_LIBERAL,
+ S(fchmod) = A_YES | A_LIBERAL,
+ S(sigaction) = A_YES | A_LIBERAL,
+ S(sgetmask) = A_YES | A_LIBERAL,
+ S(ssetmask) = A_YES | A_LIBERAL,
+ S(sigsuspend) = A_YES | A_LIBERAL,
+ S(sigpending) = A_YES | A_LIBERAL,
+ S(getrlimit) = A_YES | A_LIBERAL,
+ S(getrusage) = A_YES | A_LIBERAL,
+ S(ugetrlimit) = A_YES | A_LIBERAL,
+ S(gettimeofday) = A_YES | A_LIBERAL,
+ S(select) = A_YES | A_LIBERAL,
+ S(readdir) = A_YES | A_LIBERAL,
+ S(setitimer) = A_YES | A_LIBERAL,
+ S(getitimer) = A_YES | A_LIBERAL,
+ S(sigreturn) = A_YES | A_LIBERAL,
+ S(mprotect) = A_YES | A_LIBERAL,
+ S(sigprocmask) = A_YES | A_LIBERAL,
+ S(getdents) = A_YES | A_LIBERAL,
+ S(getdents64) = A_YES | A_LIBERAL,
+ S(_newselect) = A_YES | A_LIBERAL,
+ S(fdatasync) = A_YES | A_LIBERAL,
+ S(mremap) = A_YES | A_LIBERAL,
+ S(poll) = A_YES | A_LIBERAL,
+ S(getcwd) = A_YES | A_LIBERAL,
+ S(nanosleep) = A_YES | A_LIBERAL,
+ S(rt_sigreturn) = A_YES | A_LIBERAL,
+ S(rt_sigaction) = A_YES | A_LIBERAL,
+ S(rt_sigprocmask) = A_YES | A_LIBERAL,
+ S(rt_sigpending) = A_YES | A_LIBERAL,
+ S(rt_sigtimedwait) = A_YES | A_LIBERAL,
+ S(rt_sigqueueinfo) = A_YES | A_LIBERAL,
+ S(rt_sigsuspend) = A_YES | A_LIBERAL,
+ S(mmap2) = A_YES | A_LIBERAL,
+ S(_sysctl) = A_YES | A_LIBERAL,
+#undef S
+};
+
+static const char *
+syscall_name(unsigned int id, char *buf)
+{
+ if (id < NUM_SYSCALLS && syscall_names[id])
+ return syscall_names[id];
+ else
+ {
+ sprintf(buf, "#%d", id);
+ return buf;
+ }
+}
+
+static int
+syscall_by_name(char *name)
+{
+ for (unsigned int i=0; i<NUM_SYSCALLS; i++)
+ if (syscall_names[i] && !strcmp(syscall_names[i], name))
+ return i;
+ if (name[0] == '#')
+ name++;
+ if (!*name)
+ return -1;
+ char *ep;
+ unsigned long l = strtoul(name, &ep, 0);
+ if (*ep)
+ return -1;
+ if (l >= NUM_ACTIONS)
+ return NUM_ACTIONS;
+ return l;
+}
+
+static int
+set_syscall_action(char *a)
+{
+ char *sep = strchr(a, '=');
+ enum action act = A_YES;
+ if (sep)
+ {
+ *sep++ = 0;
+ if (!strcmp(sep, "yes"))
+ act = A_YES;
+ else if (!strcmp(sep, "no"))
+ act = A_NO;
+ else if (!strcmp(sep, "file"))
+ act = A_FILENAME;
+ else
+ return 0;
+ }
+
+ int sys = syscall_by_name(a);
+ if (sys < 0)
+ die("Unknown syscall `%s'", a);
+ if (sys >= NUM_ACTIONS)
+ die("Syscall `%s' out of range", a);
+ syscall_action[sys] = act;
+ return 1;
+}
+
+struct path_rule {
+ char *path;
+ enum action action;
+ struct path_rule *next;
+};
+
+static struct path_rule default_path_rules[] = {
+ { "/etc/", A_YES },
+ { "/lib/", A_YES },
+ { "/usr/lib/", A_YES },
+ { "/opt/lib/", A_YES },
+ { "/usr/share/zoneinfo/", A_YES },
+ { "/usr/share/locale/", A_YES },
+ { "/dev/null", A_YES },
+ { "/dev/zero", A_YES },
+ { "/proc/meminfo", A_YES },
+ { "/proc/self/stat", A_YES },
+ { "/proc/self/exe", A_YES }, // Needed by FPC 2.0.x runtime
+};
+
+static struct path_rule *user_path_rules;
+static struct path_rule **last_path_rule = &user_path_rules;
+
+static int
+set_path_action(char *a)
+{
+ char *sep = strchr(a, '=');
+ enum action act = A_YES;
+ if (sep)
+ {
+ *sep++ = 0;
+ if (!strcmp(sep, "yes"))
+ act = A_YES;
+ else if (!strcmp(sep, "no"))
+ act = A_NO;
+ else
+ return 0;
+ }
+
+ struct path_rule *r = xmalloc(sizeof(*r) + strlen(a));
+ r->path = (char *)(r+1);
+ strcpy(r->path, a);
+ r->action = act;
+ r->next = NULL;
+ *last_path_rule = r;
+ last_path_rule = &r->next;
+ return 1;
+}
+
+static enum action
+match_path_rule(struct path_rule *r, char *path)
+{
+ char *rr = r->path;
+ while (*rr)
+ if (*rr++ != *path++)
+ {
+ if (rr[-1] == '/' && !path[-1])
+ break;
+ return A_DEFAULT;
+ }
+ if (rr > r->path && rr[-1] != '/' && *path)
+ return A_DEFAULT;
+ return r->action;
+}
+
static void
valid_filename(unsigned long addr)
{
static int mem_fd;
if (!file_access)
- die("File access forbidden.");
+ die("File access forbidden");
if (file_access >= 9)
return;
if (l > remains)
l = remains;
if (!l)
- die("Access to file with name too long.");
+ die("Access to file with name too long");
if (long_seek(mem_fd, addr, SEEK_SET) < 0)
die("long_seek(mem): %m");
remains = read(mem_fd, end, l);
if (remains < 0)
die("read(mem): %m");
if (!remains)
- die("Access to file with name out of memory.");
+ die("Access to file with name out of memory");
end += l;
addr += l;
}
}
while (*p++);
- log("[%s] ", namebuf);
+ msg("[%s] ", namebuf);
if (file_access >= 3)
return;
+
+ // Everything in current directory is permitted
if (!strchr(namebuf, '/') && strcmp(namebuf, ".."))
return;
+
+ // ".." anywhere in the path is forbidden
+ enum action act = A_DEFAULT;
+ if (strstr(namebuf, ".."))
+ act = A_NO;
+
+ // Scan user rules
+ for (struct path_rule *r = user_path_rules; r && !act; r=r->next)
+ act = match_path_rule(r, namebuf);
+
+ // Scan built-in rules
if (file_access >= 2)
- {
- if ((!strncmp(namebuf, "/etc/", 5) ||
- !strncmp(namebuf, "/lib/", 5) ||
- !strncmp(namebuf, "/usr/lib/", 9))
- && !strstr(namebuf, ".."))
- return;
- if (!strcmp(namebuf, "/dev/null") ||
- !strcmp(namebuf, "/dev/zero"))
- return;
- }
- die("Forbidden access to file `%s'.", namebuf);
+ for (int i=0; i<ARRAY_SIZE(default_path_rules) && !act; i++)
+ act = match_path_rule(&default_path_rules[i], namebuf);
+
+ if (act != A_YES)
+ die("Forbidden access to file `%s'", namebuf);
}
static int
valid_syscall(struct user *u)
{
- switch (u->regs.orig_eax)
+ unsigned int sys = u->regs.orig_eax;
+ enum action act = (sys < NUM_ACTIONS) ? syscall_action[sys] : A_DEFAULT;
+
+ if (act & A_LIBERAL)
{
- case SYS_execve:
- {
- static int exec_counter;
- return !exec_counter++;
- }
- case SYS_open:
- case SYS_creat:
- case SYS_unlink:
- case SYS_oldstat:
- case SYS_access:
- case SYS_oldlstat:
- case SYS_truncate:
- case SYS_stat:
- case SYS_lstat:
- case SYS_truncate64:
- case SYS_stat64:
- case SYS_lstat64:
- valid_filename(u->regs.ebx);
+ if (filter_syscalls == 1)
+ act &= ~A_LIBERAL;
+ else
+ act = A_DEFAULT;
+ }
+ switch (act)
+ {
+ case A_YES:
return 1;
- case SYS_exit:
- case SYS_read:
- case SYS_write:
- case SYS_close:
- case SYS_lseek:
- case SYS_getpid:
- case SYS_getuid:
- case SYS_oldfstat:
- case SYS_dup:
- case SYS_brk:
- case SYS_getgid:
- case SYS_geteuid:
- case SYS_getegid:
- case SYS_dup2:
- case SYS_ftruncate:
- case SYS_fstat:
- case SYS_personality:
- case SYS__llseek:
- case SYS_readv:
- case SYS_writev:
- case SYS_getresuid:
- case SYS_pread:
- case SYS_pwrite:
- case SYS_ftruncate64:
- case SYS_fstat64:
- case SYS_fcntl:
- case SYS_mmap:
- case SYS_munmap:
- case SYS_ioctl:
+ case A_NO:
+ return 0;
+ case A_FILENAME:
+ valid_filename(u->regs.ebx);
return 1;
- case SYS_time:
- case SYS_alarm:
- case SYS_pause:
- case SYS_signal:
- case SYS_fchmod:
- case SYS_sigaction:
- case SYS_sgetmask:
- case SYS_ssetmask:
- case SYS_sigsuspend:
- case SYS_sigpending:
- case SYS_getrlimit:
- case SYS_getrusage:
- case SYS_gettimeofday:
- case SYS_select:
- case SYS_readdir:
- case SYS_setitimer:
- case SYS_getitimer:
- case SYS_sigreturn:
- case SYS_mprotect:
- case SYS_sigprocmask:
- case SYS_getdents:
- case SYS__newselect:
- case SYS_fdatasync:
- case SYS_mremap:
- case SYS_poll:
- case SYS_getcwd:
- case SYS_nanosleep:
- case SYS_rt_sigreturn:
- case SYS_rt_sigaction:
- case SYS_rt_sigprocmask:
- case SYS_rt_sigpending:
- case SYS_rt_sigtimedwait:
- case SYS_rt_sigqueueinfo:
- case SYS_rt_sigsuspend:
- case SYS_mmap2:
- return (filter_syscalls == 1);
+ default: ;
+ }
+
+ switch (sys)
+ {
+ case __NR_kill:
+ if (u->regs.ebx == box_pid)
+ die("Committed suicide by signal %d", (int)u->regs.ecx);
+ return 0;
+ case __NR_tgkill:
+ if (u->regs.ebx == box_pid && u->regs.ecx == box_pid)
+ die("Committed suicide by signal %d", (int)u->regs.edx);
+ return 0;
default:
return 0;
}
signal_int(int unused UNUSED)
{
/* Interrupts are fatal, so no synchronization requirements. */
- die("Interrupted.");
+ die("Interrupted");
}
static void
check_timeout(void)
{
- int sec;
-
- if (use_wall_clock)
- sec = time(NULL) - start_time;
- else
+ if (wall_timeout)
+ {
+ struct timeval now, wall;
+ int wall_ms;
+ gettimeofday(&now, NULL);
+ timersub(&now, &start_time, &wall);
+ wall_ms = wall.tv_sec*1000 + wall.tv_usec/1000;
+ if (wall_ms > wall_timeout)
+ die("Time limit exceeded (wall clock)");
+ if (verbose > 1)
+ fprintf(stderr, "[wall time check: %d msec]\n", wall_ms);
+ }
+ if (timeout)
{
char buf[4096], *x;
- int c, utime, stime;
+ int c, utime, stime, ms;
static int proc_status_fd;
if (!proc_status_fd)
{
x++;
if (sscanf(x, "%*c %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %d %d", &utime, &stime) != 2)
die("proc syntax error 2");
- sec = (utime + stime)/ticks_per_sec;
+ ms = (utime + stime) * 1000 / ticks_per_sec;
+ if (verbose > 1)
+ fprintf(stderr, "[time check: %d msec]\n", ms);
+ if (ms > timeout)
+ die("Time limit exceeded");
}
- if (verbose > 1)
- fprintf(stderr, "[timecheck: %d seconds]\n", sec);
- if (sec > timeout)
- die("Time limit exceeded.");
}
static void
bzero(&sa, sizeof(sa));
sa.sa_handler = signal_int;
sigaction(SIGINT, &sa, NULL);
- start_time = time(NULL);
+ gettimeofday(&start_time, NULL);
ticks_per_sec = sysconf(_SC_CLK_TCK);
if (ticks_per_sec <= 0)
die("Invalid ticks_per_sec!");
- if (timeout)
+ if (timeout || wall_timeout)
{
sa.sa_handler = signal_alarm;
sigaction(SIGALRM, &sa, NULL);
die("wait4: unknown pid %d exited!", p);
if (WIFEXITED(stat))
{
- struct timeval total;
- int wall;
+ struct timeval total, now, wall;
+ int total_ms, wall_ms;
box_pid = 0;
if (WEXITSTATUS(stat))
- die("Exited with error status %d.", WEXITSTATUS(stat));
+ die("Exited with error status %d", WEXITSTATUS(stat));
timeradd(&rus.ru_utime, &rus.ru_stime, &total);
- wall = time(NULL) - start_time;
- if ((use_wall_clock ? wall : total.tv_sec) > timeout)
- die("Timeout exceeded (after exit).");
- fprintf(stderr, "OK (%d sec real, %d sec wall, %d syscalls)\n", (int) total.tv_sec, wall, syscall_count);
+ total_ms = total.tv_sec*1000 + total.tv_usec/1000;
+ gettimeofday(&now, NULL);
+ timersub(&now, &start_time, &wall);
+ wall_ms = wall.tv_sec*1000 + wall.tv_usec/1000;
+ if (timeout && total_ms > timeout)
+ die("Time limit exceeded");
+ if (wall_timeout && wall_ms > wall_timeout)
+ die("Time limit exceeded (wall clock)");
+ fprintf(stderr, "OK (%d.%03d sec real, %d.%03d sec wall, %d syscalls)\n",
+ (int) total.tv_sec, (int) total.tv_usec/1000,
+ (int) wall.tv_sec, (int) wall.tv_usec/1000,
+ syscall_count);
exit(0);
}
if (WIFSIGNALED(stat))
{
box_pid = 0;
- die("Caught fatal signal %d.", WTERMSIG(stat));
+ die("Caught fatal signal %d%s", WTERMSIG(stat), (syscall_count ? "" : " during startup"));
}
if (WIFSTOPPED(stat))
{
die("ptrace(PTRACE_GETREGS): %m");
stop_count++;
if (!stop_count) /* Traceme request */
- log(">> Traceme request caught\n");
+ msg(">> Traceme request caught\n");
else if (stop_count & 1) /* Syscall entry */
{
- log(">> Syscall %3ld (%08lx,%08lx,%08lx) ", u.regs.orig_eax, u.regs.ebx, u.regs.ecx, u.regs.edx);
- syscall_count++;
- if (!valid_syscall(&u))
+ char namebuf[32];
+ msg(">> Syscall %-12s (%08lx,%08lx,%08lx) ", syscall_name(u.regs.orig_eax, namebuf), u.regs.ebx, u.regs.ecx, u.regs.edx);
+ if (!exec_seen)
+ {
+ msg("[master] ");
+ if (u.regs.orig_eax == __NR_execve)
+ exec_seen = 1;
+ }
+ else if (valid_syscall(&u))
+ syscall_count++;
+ else
{
/*
* Unfortunately, PTRACE_KILL kills _after_ the syscall completes,
u.regs.orig_eax = 0xffffffff;
if (ptrace(PTRACE_SETREGS, box_pid, NULL, &u) < 0)
die("ptrace(PTRACE_SETREGS): %m");
- die("Forbidden syscall %d.", sys);
+ die("Forbidden syscall %s", syscall_name(sys, namebuf));
}
}
else /* Syscall return */
- log("= %ld\n", u.regs.eax);
+ msg("= %ld\n", u.regs.eax);
ptrace(PTRACE_SYSCALL, box_pid, 0, 0);
}
else if (sig != SIGSTOP && sig != SIGXCPU && sig != SIGXFSZ)
{
- log(">> Signal %d\n", sig);
+ msg(">> Signal %d\n", sig);
ptrace(PTRACE_SYSCALL, box_pid, 0, sig);
}
else
- die("Received signal %d.", sig);
+ die("Received signal %d", sig);
}
else
die("wait4: unknown status %x, giving up!", stat);
{
struct rlimit rl;
char *args[argc+1];
- char *env[1] = { NULL };
+ char *env[] = { "LIBC_FATAL_STDERR_=1", NULL };
memcpy(args, argv, argc * sizeof(char *));
args[argc] = NULL;
- close(2);
- dup(1);
+ if (set_cwd && chdir(set_cwd))
+ die("chdir: %m");
+ if (redir_stdin)
+ {
+ close(0);
+ if (open(redir_stdin, O_RDONLY) != 0)
+ die("open(\"%s\"): %m", redir_stdin);
+ }
+ if (redir_stdout)
+ {
+ close(1);
+ if (open(redir_stdout, O_WRONLY | O_CREAT | O_TRUNC, 0666) != 1)
+ die("open(\"%s\"): %m", redir_stdout);
+ }
+ dup2(1, 2);
setpgrp();
if (memory_limit)
{
rl.rlim_cur = rl.rlim_max = 64;
if (setrlimit(RLIMIT_NOFILE, &rl) < 0)
die("setrlimit: %m");
- if (filter_syscalls && ptrace(PTRACE_TRACEME) < 0)
- die("ptrace(PTRACE_TRACEME): %m");
+ if (filter_syscalls)
+ {
+ if (ptrace(PTRACE_TRACEME) < 0)
+ die("ptrace(PTRACE_TRACEME): %m");
+ /* Trick: Make sure that we are stopped until the boxkeeper wakes up. */
+ signal(SIGCHLD, SIG_IGN);
+ raise(SIGCHLD);
+ }
execve(args[0], args, (pass_environ ? environ : env));
die("execve(\"%s\"): %m", args[0]);
}
-c <dir>\tChange directory to <dir> first\n\
-e\t\tPass full environment of parent process\n\
-f\t\tFilter system calls (-ff=very restricted)\n\
+-i <file>\tRedirect stdin from <file>\n\
-m <size>\tLimit address space to <size> KB\n\
--t <time>\tStop after <time> seconds\n\
+-o <file>\tRedirect stdout to <file>\n\
+-p <path>\tPermit access to the specified path (or subtree if it ends with a `/')\n\
+-p <path>=<act>\tDefine action for the specified path (<act>=yes/no)\n\
+-s <sys>\tPermit the specified syscall (be careful)\n\
+-s <sys>=<act>\tDefine action for the specified syscall (<act>=yes/no/file)\n\
+-t <time>\tSet run time limit (seconds, fractions allowed)\n\
+-T\t\tAllow syscalls for measuring run time\n\
-v\t\tBe verbose\n\
--w\t\tMeasure wall clock time instead of run time\n\
+-w <time>\tSet wall clock time limit (seconds, fractions allowed)\n\
");
exit(1);
}
{
int c;
uid_t uid;
- char *cwd = NULL;
- while ((c = getopt(argc, argv, "a:c:efm:t:vw")) >= 0)
+ while ((c = getopt(argc, argv, "a:c:efi:m:o:p:s:t:Tvw:")) >= 0)
switch (c)
{
case 'a':
file_access = atol(optarg);
break;
case 'c':
- cwd = optarg;
+ set_cwd = optarg;
break;
case 'e':
pass_environ = 1;
case 'f':
filter_syscalls++;
break;
+ case 'i':
+ redir_stdin = optarg;
+ break;
case 'm':
memory_limit = atol(optarg);
break;
+ case 'o':
+ redir_stdout = optarg;
+ break;
+ case 'p':
+ if (!set_path_action(optarg))
+ usage();
+ break;
+ case 's':
+ if (!set_syscall_action(optarg))
+ usage();
+ break;
case 't':
- timeout = atol(optarg);
+ timeout = 1000*atof(optarg);
+ break;
+ case 'T':
+ syscall_action[__NR_times] = A_YES;
break;
case 'v':
verbose++;
break;
case 'w':
- use_wall_clock = 1;
+ wall_timeout = 1000*atof(optarg);
break;
default:
usage();
uid = geteuid();
if (setreuid(uid, uid) < 0)
die("setreuid: %m");
- if (cwd && chdir(cwd))
- die("chdir: %m");
box_pid = fork();
if (box_pid < 0)
die("fork: %m");
projects / eval.git / blobdiff