2 * A Process Isolator based on Linux Containers
4 * (c) 2012 Martin Mares <mj@ucw.cz>
5 * (c) 2012 Bernard Blackham <bernard@blackham.com.au>
26 #include <sys/signal.h>
27 #include <sys/resource.h>
28 #include <sys/mount.h>
31 #define NONRET __attribute__((noreturn))
32 #define UNUSED __attribute__((unused))
33 #define ARRAY_SIZE(a) (int)(sizeof(a)/sizeof(a[0]))
35 #define BOX_DIR CONFIG_ISOLATE_BOX_DIR
36 #define BOX_UID CONFIG_ISOLATE_BOX_UID
37 #define BOX_GID CONFIG_ISOLATE_BOX_GID
39 static int timeout; /* milliseconds */
40 static int wall_timeout;
41 static int extra_timeout;
42 static int pass_environ;
44 static int memory_limit;
45 static int stack_limit;
46 static int max_processes = 1;
47 static char *redir_stdin, *redir_stdout, *redir_stderr;
50 static int cg_memory_limit;
52 static char *cg_root = "/sys/fs/cgroup";
54 static uid_t orig_uid;
55 static gid_t orig_gid;
58 static int partial_line;
59 static char cleanup_cmd[256];
61 static struct timeval start_time;
62 static int ticks_per_sec;
63 static int total_ms, wall_ms;
64 static volatile sig_atomic_t timer_tick;
66 static int error_pipes[2];
67 static int write_errors_to_fd;
68 static int read_errors_from_fd;
70 static void die(char *msg, ...) NONRET;
71 static void cg_stats(void);
72 static int get_wall_time_ms(void);
73 static int get_run_time_ms(struct rusage *rus);
77 static FILE *metafile;
80 meta_open(const char *name)
82 if (!strcmp(name, "-"))
87 metafile = fopen(name, "w");
89 die("Failed to open metafile '%s'",name);
95 if (metafile && metafile != stdout)
99 static void __attribute__((format(printf,1,2)))
100 meta_printf(const char *fmt, ...)
107 vfprintf(metafile, fmt, args);
112 final_stats(struct rusage *rus)
114 total_ms = get_run_time_ms(rus);
115 wall_ms = get_wall_time_ms();
117 meta_printf("time:%d.%03d\n", total_ms/1000, total_ms%1000);
118 meta_printf("time-wall:%d.%03d\n", wall_ms/1000, wall_ms%1000);
119 meta_printf("max-rss:%ld\n", rus->ru_maxrss);
120 meta_printf("csw-voluntary:%ld\n", rus->ru_nvcsw);
121 meta_printf("csw-forced:%ld\n", rus->ru_nivcsw);
126 /*** Messages and exits ***/
129 xsystem(const char *cmd)
131 int ret = system(cmd);
133 die("system(\"%s\"): %m", cmd);
134 if (!WIFEXITED(ret) || WEXITSTATUS(ret))
135 die("system(\"%s\"): Exited with status %d", cmd, ret);
143 kill(-box_pid, SIGKILL);
144 kill(box_pid, SIGKILL);
145 meta_printf("killed:1\n");
150 p = wait4(box_pid, &stat, 0, &rus);
151 while (p < 0 && errno == EINTR);
153 fprintf(stderr, "UGH: Lost track of the process (%m)\n");
158 if (rc < 2 && cleanup_cmd[0])
159 xsystem(cleanup_cmd);
173 /* Report an error of the sandbox itself */
174 static void NONRET __attribute__((format(printf,1,2)))
180 int n = vsnprintf(buf, sizeof(buf), msg, args);
182 if (write_errors_to_fd)
184 // We are inside the box, have to use error pipe for error reporting.
185 // We hope that the whole error message fits in PIPE_BUF bytes.
186 write(write_errors_to_fd, buf, n);
190 // Otherwise, we in the box keeper process, so we report errors normally
192 meta_printf("status:XX\nmessage:%s\n", buf);
198 /* Report an error of the program inside the sandbox */
199 static void NONRET __attribute__((format(printf,1,2)))
205 if (msg[0] && msg[1] && msg[2] == ':' && msg[3] == ' ')
207 meta_printf("status:%c%c\n", msg[0], msg[1]);
211 vsnprintf(buf, sizeof(buf), msg, args);
212 meta_printf("message:%s\n", buf);
218 /* Write a message, but only if in verbose mode */
219 static void __attribute__((format(printf,1,2)))
226 int len = strlen(msg);
228 partial_line = (msg[len-1] != '\n');
229 vfprintf(stderr, msg, args);
235 /*** Utility functions ***/
240 void *p = malloc(size);
242 die("Out of memory");
249 char *p = strdup(str);
251 die("Out of memory");
255 static int dir_exists(char *path)
258 return (stat(path, &st) >= 0 && S_ISDIR(st.st_mode));
261 /*** Environment rules ***/
264 char *var; // Variable to match
265 char *val; // ""=clear, NULL=inherit
267 struct env_rule *next;
270 static struct env_rule *first_env_rule;
271 static struct env_rule **last_env_rule = &first_env_rule;
273 static struct env_rule default_env_rules[] = {
274 { "LIBC_FATAL_STDERR_", "1" }
278 set_env_action(char *a0)
280 struct env_rule *r = xmalloc(sizeof(*r) + strlen(a0) + 1);
281 char *a = (char *)(r+1);
284 char *sep = strchr(a, '=');
296 last_env_rule = &r->next;
302 match_env_var(char *env_entry, struct env_rule *r)
304 if (strncmp(env_entry, r->var, r->var_len))
306 return (env_entry[r->var_len] == '=');
310 apply_env_rule(char **env, int *env_sizep, struct env_rule *r)
312 // First remove the variable if already set
314 while (pos < *env_sizep && !match_env_var(env[pos], r))
316 if (pos < *env_sizep)
319 env[pos] = env[*env_sizep];
320 env[*env_sizep] = NULL;
323 // What is the new value?
329 new = xmalloc(r->var_len + 1 + strlen(r->val) + 1);
330 sprintf(new, "%s=%s", r->var, r->val);
335 while (environ[pos] && !match_env_var(environ[pos], r))
337 if (!(new = environ[pos]))
341 // Add it at the end of the array
342 env[(*env_sizep)++] = new;
343 env[*env_sizep] = NULL;
347 setup_environment(void)
349 // Link built-in rules with user rules
350 for (int i=ARRAY_SIZE(default_env_rules)-1; i >= 0; i--)
352 default_env_rules[i].next = first_env_rule;
353 first_env_rule = &default_env_rules[i];
356 // Scan the original environment
357 char **orig_env = environ;
359 while (orig_env[orig_size])
362 // For each rule, reserve one more slot and calculate length
364 for (struct env_rule *r = first_env_rule; r; r=r->next)
367 r->var_len = strlen(r->var);
370 // Create a new environment
371 char **env = xmalloc((orig_size + num_rules + 1) * sizeof(char *));
375 memcpy(env, environ, orig_size * sizeof(char *));
382 // Apply the rules one by one
383 for (struct env_rule *r = first_env_rule; r; r=r->next)
384 apply_env_rule(env, &size, r);
386 // Return the new env and pass some gossip
389 fprintf(stderr, "Passing environment:\n");
390 for (int i=0; env[i]; i++)
391 fprintf(stderr, "\t%s\n", env[i]);
396 /*** Mount rules ***/
399 char *inside; // A relative path
400 char *outside; // This can be an absolute path or a relative path starting with "./"
401 unsigned int flags; // DIR_FLAG_xxx
402 struct dir_rule *next;
405 enum dir_rule_flags {
413 static const char * const dir_flag_names[] = { "rw", "noexec", "fs", "maybe", "dev" };
415 static struct dir_rule *first_dir_rule;
416 static struct dir_rule **last_dir_rule = &first_dir_rule;
418 static int add_dir_rule(char *in, char *out, unsigned int flags)
420 // Make sure that "in" is relative
427 if (flags & DIR_FLAG_FS)
429 if (!out || out[0] == '/')
434 if (out && out[0] != '/' && strncmp(out, "./", 2))
438 // Override an existing rule
440 for (r = first_dir_rule; r; r = r->next)
441 if (!strcmp(r->inside, in))
447 r = xmalloc(sizeof(*r));
450 last_dir_rule = &r->next;
458 static unsigned int parse_dir_option(char *opt)
460 for (unsigned int i = 0; i < ARRAY_SIZE(dir_flag_names); i++)
461 if (!strcmp(opt, dir_flag_names[i]))
463 die("Unknown directory option %s", opt);
466 static int set_dir_action(char *arg)
470 char *colon = strchr(arg, ':');
471 unsigned int flags = 0;
475 char *next = strchr(colon, ':');
478 flags |= parse_dir_option(colon);
482 char *eq = strchr(arg, '=');
486 return add_dir_rule(arg, (*eq ? eq : NULL), flags);
490 char *out = xmalloc(1 + strlen(arg) + 1);
491 sprintf(out, "/%s", arg);
492 return add_dir_rule(arg, out, flags);
496 static void init_dir_rules(void)
498 set_dir_action("box=./box:rw");
499 set_dir_action("bin");
500 set_dir_action("dev:dev");
501 set_dir_action("lib");
502 set_dir_action("lib64:maybe");
503 set_dir_action("proc=proc:fs");
504 set_dir_action("usr");
507 static void make_dir(char *path)
512 sep = strchr(sep, '/');
516 if (!dir_exists(path) && mkdir(path, 0777) < 0)
517 die("Cannot create directory %s: %m\n", path);
525 static void apply_dir_rules(void)
527 for (struct dir_rule *r = first_dir_rule; r; r=r->next)
529 char *in = r->inside;
530 char *out = r->outside;
533 msg("Not binding anything on %s\n", r->inside);
537 if ((r->flags & DIR_FLAG_MAYBE) && !dir_exists(out))
539 msg("Not binding %s on %s (does not exist)\n", out, r->inside);
544 snprintf(root_in, sizeof(root_in), "root/%s", in);
547 unsigned long mount_flags = 0;
548 if (!(r->flags & DIR_FLAG_RW))
549 mount_flags |= MS_RDONLY;
550 if (r->flags & DIR_FLAG_NOEXEC)
551 mount_flags |= MS_NOEXEC;
552 if (!(r->flags & DIR_FLAG_DEV))
553 mount_flags |= MS_NODEV;
555 if (r->flags & DIR_FLAG_FS)
557 msg("Mounting %s on %s (flags %lx)\n", out, in, mount_flags);
558 if (mount("none", root_in, out, mount_flags, "") < 0)
559 die("Cannot mount %s on %s: %m", out, in);
563 mount_flags |= MS_BIND | MS_NOSUID;
564 msg("Binding %s on %s (flags %lx)\n", out, in, mount_flags);
565 // Most mount flags need remount to work
566 if (mount(out, root_in, "none", mount_flags, "") < 0 ||
567 mount(out, root_in, "none", MS_REMOUNT | mount_flags, "") < 0)
568 die("Cannot mount %s on %s: %m", out, in);
573 /*** Control groups ***/
575 static char cg_path[256];
577 #define CG_BUFSIZE 1024
580 cg_read(char *attr, char *buf)
590 snprintf(path, sizeof(path), "%s/%s", cg_path, attr);
592 int fd = open(path, O_RDONLY);
597 die("Cannot read %s: %m", path);
600 int n = read(fd, buf, CG_BUFSIZE);
602 die("Cannot read %s: %m", path);
603 if (n >= CG_BUFSIZE - 1)
604 die("Attribute %s too long", path);
605 if (n > 0 && buf[n-1] == '\n')
610 msg("CG: Read %s = %s\n", attr, buf);
616 static void __attribute__((format(printf,2,3)))
617 cg_write(char *attr, char *fmt, ...)
622 char buf[CG_BUFSIZE];
623 int n = vsnprintf(buf, sizeof(buf), fmt, args);
625 die("cg_writef: Value for attribute %s is too long", attr);
628 msg("CG: Write %s = %s", attr, buf);
631 snprintf(path, sizeof(path), "%s/%s", cg_path, attr);
633 int fd = open(path, O_WRONLY | O_TRUNC);
635 die("Cannot write %s: %m", path);
637 int written = write(fd, buf, n);
639 die("Cannot set %s to %s: %m", path, buf);
641 die("Short write to %s (%d out of %d bytes)", path, written, n);
653 if (!dir_exists(cg_root))
654 die("Control group filesystem at %s not mounted", cg_root);
656 snprintf(cg_path, sizeof(cg_path), "%s/box-%d", cg_root, BOX_UID);
657 msg("Using control group %s\n", cg_path);
667 char buf[CG_BUFSIZE];
669 if (stat(cg_path, &st) >= 0 || errno != ENOENT)
671 msg("Control group %s already exists, trying to empty it.\n", cg_path);
672 if (rmdir(cg_path) < 0)
673 die("Failed to reset control group %s: %m", cg_path);
676 if (mkdir(cg_path, 0777) < 0)
677 die("Failed to create control group %s: %m", cg_path);
679 // If cpuset module is enabled, copy allowed cpus and memory nodes from parent group
680 if (cg_read("?../cpuset.cpus", buf))
681 cg_write("cpuset.cpus", "%s", buf);
682 if (cg_read("?../cpuset.mems", buf))
683 cg_write("cpuset.mems", "%s", buf);
692 msg("Entering control group %s\n", cg_path);
695 if (stat(cg_path, &st) < 0)
696 die("Control group %s does not exist: %m", cg_path);
700 cg_write("memory.limit_in_bytes", "%lld\n", (long long) cg_memory_limit << 10);
701 cg_write("memory.memsw.limit_in_bytes", "%lld\n", (long long) cg_memory_limit << 10);
705 cg_write("cpuacct.usage", "0\n");
707 cg_write("tasks", "%d\n", (int) getpid());
711 cg_get_run_time_ms(void)
716 char buf[CG_BUFSIZE];
717 cg_read("cpuacct.usage", buf);
718 unsigned long long ns = atoll(buf);
728 char buf[CG_BUFSIZE];
730 // Memory usage statistics
731 unsigned long long mem=0, memsw=0;
732 if (cg_read("?memory.max_usage_in_bytes", buf))
734 if (cg_read("?memory.memsw.max_usage_in_bytes", buf))
741 meta_printf("cg-mem:%lld\n", mem >> 10);
747 char buf[CG_BUFSIZE];
752 cg_read("tasks", buf);
754 die("Some tasks left in control group %s, failed to remove it", cg_path);
756 if (rmdir(cg_path) < 0)
757 die("Cannot remove control group %s: %m", cg_path);
760 /*** The keeper process ***/
763 signal_alarm(int unused UNUSED)
765 /* Time limit checks are synchronous, so we only schedule them there. */
771 signal_int(int unused UNUSED)
773 /* Interrupts are fatal, so no synchronization requirements. */
774 meta_printf("exitsig:%d\n", SIGINT);
775 err("SG: Interrupted");
778 #define PROC_BUF_SIZE 4096
780 read_proc_file(char *buf, char *name, int *fdp)
786 sprintf(buf, "/proc/%d/%s", (int) box_pid, name);
787 *fdp = open(buf, O_RDONLY);
789 die("open(%s): %m", buf);
791 lseek(*fdp, 0, SEEK_SET);
792 if ((c = read(*fdp, buf, PROC_BUF_SIZE-1)) < 0)
793 die("read on /proc/$pid/%s: %m", name);
794 if (c >= PROC_BUF_SIZE-1)
795 die("/proc/$pid/%s too long", name);
800 get_wall_time_ms(void)
802 struct timeval now, wall;
803 gettimeofday(&now, NULL);
804 timersub(&now, &start_time, &wall);
805 return wall.tv_sec*1000 + wall.tv_usec/1000;
809 get_run_time_ms(struct rusage *rus)
812 return cg_get_run_time_ms();
816 struct timeval total;
817 timeradd(&rus->ru_utime, &rus->ru_stime, &total);
818 return total.tv_sec*1000 + total.tv_usec/1000;
821 char buf[PROC_BUF_SIZE], *x;
823 static int proc_stat_fd;
825 read_proc_file(buf, "stat", &proc_stat_fd);
827 while (*x && *x != ' ')
832 die("proc stat syntax error 1");
833 while (*x && (*x != ')' || x[1] != ' '))
835 while (*x == ')' || *x == ' ')
837 if (sscanf(x, "%*c %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %d %d", &utime, &stime) != 2)
838 die("proc stat syntax error 2");
840 return (utime + stime) * 1000 / ticks_per_sec;
848 int wall_ms = get_wall_time_ms();
849 if (wall_ms > wall_timeout)
850 err("TO: Time limit exceeded (wall clock)");
852 fprintf(stderr, "[wall time check: %d msec]\n", wall_ms);
856 int ms = get_run_time_ms(NULL);
858 fprintf(stderr, "[time check: %d msec]\n", ms);
859 if (ms > timeout && ms > extra_timeout)
860 err("TO: Time limit exceeded");
867 read_errors_from_fd = error_pipes[0];
868 close(error_pipes[1]);
871 bzero(&sa, sizeof(sa));
872 sa.sa_handler = signal_int;
873 sigaction(SIGINT, &sa, NULL);
875 gettimeofday(&start_time, NULL);
876 ticks_per_sec = sysconf(_SC_CLK_TCK);
877 if (ticks_per_sec <= 0)
878 die("Invalid ticks_per_sec!");
880 if (timeout || wall_timeout)
882 sa.sa_handler = signal_alarm;
883 sigaction(SIGALRM, &sa, NULL);
897 p = wait4(box_pid, &stat, 0, &rus);
905 die("wait4: unknown pid %d exited!", p);
908 // Check error pipe if there is an internal error passed from inside the box
910 int n = read(read_errors_from_fd, interr, sizeof(interr) - 1);
920 if (WEXITSTATUS(stat))
922 meta_printf("exitcode:%d\n", WEXITSTATUS(stat));
923 err("RE: Exited with error status %d", WEXITSTATUS(stat));
925 if (timeout && total_ms > timeout)
926 err("TO: Time limit exceeded");
927 if (wall_timeout && wall_ms > wall_timeout)
928 err("TO: Time limit exceeded (wall clock)");
930 fprintf(stderr, "OK (%d.%03d sec real, %d.%03d sec wall)\n",
931 total_ms/1000, total_ms%1000,
932 wall_ms/1000, wall_ms%1000);
935 else if (WIFSIGNALED(stat))
937 meta_printf("exitsig:%d\n", WTERMSIG(stat));
939 err("SG: Caught fatal signal %d", WTERMSIG(stat));
941 else if (WIFSTOPPED(stat))
943 meta_printf("exitsig:%d\n", WSTOPSIG(stat));
945 err("SG: Stopped by signal %d", WSTOPSIG(stat));
948 die("wait4: unknown status %x, giving up!", stat);
952 /*** The process running inside the box ***/
957 if (mkdir("root", 0750) < 0 && errno != EEXIST)
958 die("mkdir('root'): %m");
960 if (mount("none", "root", "tmpfs", 0, "mode=755") < 0)
961 die("Cannot mount root ramdisk: %m");
965 if (chroot("root") < 0)
966 die("Chroot failed: %m");
968 if (chdir("root/box") < 0)
969 die("Cannot change current directory: %m");
973 setup_credentials(void)
975 if (setresgid(BOX_GID, BOX_GID, BOX_GID) < 0)
976 die("setresgid: %m");
977 if (setgroups(0, NULL) < 0)
978 die("setgroups: %m");
979 if (setresuid(BOX_UID, BOX_UID, BOX_UID) < 0)
980 die("setresuid: %m");
990 if (open(redir_stdin, O_RDONLY) != 0)
991 die("open(\"%s\"): %m", redir_stdin);
996 if (open(redir_stdout, O_WRONLY | O_CREAT | O_TRUNC, 0666) != 1)
997 die("open(\"%s\"): %m", redir_stdout);
1002 if (open(redir_stderr, O_WRONLY | O_CREAT | O_TRUNC, 0666) != 2)
1003 die("open(\"%s\"): %m", redir_stderr);
1010 setup_rlim(const char *res_name, int res, rlim_t limit)
1012 struct rlimit rl = { .rlim_cur = limit, .rlim_max = limit };
1013 if (setrlimit(res, &rl) < 0)
1014 die("setrlimit(%s, %jd)", res_name, (intmax_t) limit);
1020 #define RLIM(res, val) setup_rlim("RLIMIT_" #res, RLIMIT_##res, val)
1023 RLIM(AS, memory_limit * 1024);
1025 RLIM(STACK, (stack_limit ? (rlim_t)stack_limit * 1024 : RLIM_INFINITY));
1030 RLIM(NPROC, max_processes);
1036 box_inside(void *arg)
1039 write_errors_to_fd = error_pipes[1];
1040 close(error_pipes[0]);
1044 setup_credentials();
1047 char **env = setup_environment();
1049 execve(args[0], args, env);
1050 die("execve(\"%s\"): %m", args[0]);
1058 msg("Preparing sandbox directory\n");
1059 xsystem("rm -rf box");
1060 if (mkdir("box", 0700) < 0)
1061 die("Cannot create box: %m");
1062 if (chown("box", orig_uid, orig_gid) < 0)
1063 die("Cannot chown box: %m");
1071 if (!dir_exists("box"))
1072 die("Box directory not found, there isn't anything to clean up");
1074 msg("Deleting sandbox directory\n");
1075 xsystem("rm -rf box");
1082 if (!dir_exists("box"))
1083 die("Box directory not found, did you run `isolate --init'?");
1086 snprintf(cmd, sizeof(cmd), "chown -R %d.%d box", BOX_UID, BOX_GID);
1088 snprintf(cleanup_cmd, sizeof(cleanup_cmd), "chown -R %d.%d box", orig_uid, orig_gid);
1090 if (pipe(error_pipes) < 0)
1092 for (int i=0; i<2; i++)
1093 if (fcntl(error_pipes[i], F_SETFD, fcntl(error_pipes[i], F_GETFD) | FD_CLOEXEC) < 0 ||
1094 fcntl(error_pipes[i], F_SETFL, fcntl(error_pipes[i], F_GETFL) | O_NONBLOCK) < 0)
1095 die("fcntl on pipe: %m");
1098 box_inside, // Function to execute as the body of the new process
1099 argv, // Pass our stack
1100 SIGCHLD | CLONE_NEWIPC | CLONE_NEWNET | CLONE_NEWNS | CLONE_NEWPID,
1101 argv); // Pass the arguments
1105 die("clone returned 0");
1112 printf("Process isolator 1.0\n");
1113 printf("(c) 2012 Martin Mares and Bernard Blackham\n");
1114 printf("\nCompile-time configuration:\n");
1115 printf("Sandbox directory: %s\n", BOX_DIR);
1116 printf("Sandbox credentials: uid=%u gid=%u\n", BOX_UID, BOX_GID);
1124 fprintf(stderr, "Invalid arguments!\n");
1126 Usage: isolate [<options>] <command>\n\
1129 -c, --cg[=<parent>]\tPut process in a control group (optionally a sub-group of <parent>)\n\
1130 --cg-mem=<size>\tLimit memory usage of the control group to <size> KB\n\
1131 --cg-timing\t\tTime limits affects total run time of the control group\n\
1132 -d, --dir=<dir>\t\tMake a directory <dir> visible inside the sandbox\n\
1133 --dir=<in>=<out>\tMake a directory <out> outside visible as <in> inside\n\
1134 --dir=<in>=\t\tDelete a previously defined directory rule (even a default one)\n\
1135 --dir=...:<opt>\tSpecify options for a rule:\n\
1136 \t\t\t\tdev\tAllow access to special files\n\
1137 \t\t\t\tfs\tMount a filesystem (e.g., --dir=/proc:proc:fs)\n\
1138 \t\t\t\tmaybe\tSkip the rule if <out> does not exist\n\
1139 \t\t\t\tnoexec\tDo not allow execution of binaries\n\
1140 \t\t\t\trw\tAllow read-write access\n\
1141 -E, --env=<var>\t\tInherit the environment variable <var> from the parent process\n\
1142 -E, --env=<var>=<val>\tSet the environment variable <var> to <val>; unset it if <var> is empty\n\
1143 -x, --extra-time=<time>\tSet extra timeout, before which a timing-out program is not yet killed,\n\
1144 \t\t\tso that its real execution time is reported (seconds, fractions allowed)\n\
1145 -e, --full-env\t\tInherit full environment of the parent process\n\
1146 -m, --mem=<size>\tLimit address space to <size> KB\n\
1147 -M, --meta=<file>\tOutput process information to <file> (name:value)\n\
1148 -k, --stack=<size>\tLimit stack size to <size> KB (default: 0=unlimited)\n\
1149 -r, --stderr=<file>\tRedirect stderr to <file>\n\
1150 -i, --stdin=<file>\tRedirect stdin from <file>\n\
1151 -o, --stdout=<file>\tRedirect stdout to <file>\n\
1152 -p, --processes[=<max>]\tEnable multiple processes (at most <max> of them); needs --cg\n\
1153 -t, --time=<time>\tSet run time limit (seconds, fractions allowed)\n\
1154 -v, --verbose\t\tBe verbose (use multiple times for even more verbosity)\n\
1155 -w, --wall-time=<time>\tSet wall clock time limit (seconds, fractions allowed)\n\
1158 --init\t\tInitialize sandbox (and its control group when --cg is used)\n\
1159 --run -- <cmd> ...\tRun given command within sandbox\n\
1160 --cleanup\t\tClean up sandbox\n\
1161 --version\t\tDisplay program version and configuration\n\
1175 static const char short_opts[] = "c::d:eE:i:k:m:M:o:p::r:t:vw:x:";
1177 static const struct option long_opts[] = {
1178 { "cg", 2, NULL, 'c' },
1179 { "cg-mem", 1, NULL, OPT_CG_MEM },
1180 { "cg-timing", 0, NULL, OPT_CG_TIMING },
1181 { "cleanup", 0, NULL, OPT_CLEANUP },
1182 { "dir", 1, NULL, 'd' },
1183 { "env", 1, NULL, 'E' },
1184 { "extra-time", 1, NULL, 'x' },
1185 { "full-env", 0, NULL, 'e' },
1186 { "init", 0, NULL, OPT_INIT },
1187 { "mem", 1, NULL, 'm' },
1188 { "meta", 1, NULL, 'M' },
1189 { "processes", 2, NULL, 'p' },
1190 { "run", 0, NULL, OPT_RUN },
1191 { "stack", 1, NULL, 'k' },
1192 { "stderr", 1, NULL, 'r' },
1193 { "stdin", 1, NULL, 'i' },
1194 { "stdout", 1, NULL, 'o' },
1195 { "time", 1, NULL, 't' },
1196 { "verbose", 0, NULL, 'v' },
1197 { "version", 0, NULL, OPT_VERSION },
1198 { "wall-time", 1, NULL, 'w' },
1199 { NULL, 0, NULL, 0 }
1203 main(int argc, char **argv)
1206 enum opt_code mode = 0;
1210 while ((c = getopt_long(argc, argv, short_opts, long_opts, NULL)) >= 0)
1219 if (!set_dir_action(optarg))
1226 if (!set_env_action(optarg))
1230 stack_limit = atoi(optarg);
1233 redir_stdin = optarg;
1236 memory_limit = atoi(optarg);
1242 redir_stdout = optarg;
1246 max_processes = atoi(optarg);
1251 redir_stderr = optarg;
1254 timeout = 1000*atof(optarg);
1260 wall_timeout = 1000*atof(optarg);
1263 extra_timeout = 1000*atof(optarg);
1272 cg_memory_limit = atoi(optarg);
1283 if (mode == OPT_VERSION)
1290 die("Must be started as root");
1291 orig_uid = getuid();
1292 orig_gid = getgid();
1295 if (chdir(BOX_DIR) < 0)
1296 die("chdir(%s): %m", BOX_DIR);
1317 die("Internal error: mode mismatch");