]> mj.ucw.cz Git - eval.git/blob - isolate/isolate.c
Isolate: Fix up some bugs
[eval.git] / isolate / isolate.c
1 /*
2  *      A Process Isolator based on Linux Containers
3  *
4  *      (c) 2012 Martin Mares <mj@ucw.cz>
5  *      (c) 2012 Bernard Blackham <bernard@blackham.com.au>
6  */
7
8 #define _GNU_SOURCE
9
10 #include "autoconf.h"
11
12 #include <errno.h>
13 #include <stdio.h>
14 #include <fcntl.h>
15 #include <stdlib.h>
16 #include <string.h>
17 #include <stdarg.h>
18 #include <stdint.h>
19 #include <unistd.h>
20 #include <getopt.h>
21 #include <sched.h>
22 #include <time.h>
23 #include <grp.h>
24 #include <sys/wait.h>
25 #include <sys/time.h>
26 #include <sys/signal.h>
27 #include <sys/resource.h>
28 #include <sys/mount.h>
29 #include <sys/stat.h>
30
31 #define NONRET __attribute__((noreturn))
32 #define UNUSED __attribute__((unused))
33 #define ARRAY_SIZE(a) (int)(sizeof(a)/sizeof(a[0]))
34
35 static int timeout;                     /* milliseconds */
36 static int wall_timeout;
37 static int extra_timeout;
38 static int pass_environ;
39 static int verbose;
40 static int memory_limit;
41 static int stack_limit;
42 static int max_processes = 1;
43 static char *redir_stdin, *redir_stdout, *redir_stderr;
44
45 static int cg_enable;
46 static int cg_memory_limit;
47 static int cg_timing;
48
49 static int box_id;
50 static char box_dir[1024];
51 static pid_t box_pid;
52
53 static uid_t box_uid;
54 static gid_t box_gid;
55 static uid_t orig_uid;
56 static gid_t orig_gid;
57
58 static int partial_line;
59 static char cleanup_cmd[256];
60
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;
65
66 static int error_pipes[2];
67 static int write_errors_to_fd;
68 static int read_errors_from_fd;
69
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);
74
75 /*** Meta-files ***/
76
77 static FILE *metafile;
78
79 static void
80 meta_open(const char *name)
81 {
82   if (!strcmp(name, "-"))
83     {
84       metafile = stdout;
85       return;
86     }
87   metafile = fopen(name, "w");
88   if (!metafile)
89     die("Failed to open metafile '%s'",name);
90 }
91
92 static void
93 meta_close(void)
94 {
95   if (metafile && metafile != stdout)
96     fclose(metafile);
97 }
98
99 static void __attribute__((format(printf,1,2)))
100 meta_printf(const char *fmt, ...)
101 {
102   if (!metafile)
103     return;
104
105   va_list args;
106   va_start(args, fmt);
107   vfprintf(metafile, fmt, args);
108   va_end(args);
109 }
110
111 static void
112 final_stats(struct rusage *rus)
113 {
114   total_ms = get_run_time_ms(rus);
115   wall_ms = get_wall_time_ms();
116
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);
122
123   cg_stats();
124 }
125
126 /*** Messages and exits ***/
127
128 static void
129 xsystem(const char *cmd)
130 {
131   int ret = system(cmd);
132   if (ret < 0)
133     die("system(\"%s\"): %m", cmd);
134   if (!WIFEXITED(ret) || WEXITSTATUS(ret))
135     die("system(\"%s\"): Exited with status %d", cmd, ret);
136 }
137
138 static void NONRET
139 box_exit(int rc)
140 {
141   if (box_pid > 0)
142     {
143       kill(-box_pid, SIGKILL);
144       kill(box_pid, SIGKILL);
145       meta_printf("killed:1\n");
146
147       struct rusage rus;
148       int p, stat;
149       do
150         p = wait4(box_pid, &stat, 0, &rus);
151       while (p < 0 && errno == EINTR);
152       if (p < 0)
153         fprintf(stderr, "UGH: Lost track of the process (%m)\n");
154       else
155         final_stats(&rus);
156     }
157
158   if (rc < 2 && cleanup_cmd[0])
159     xsystem(cleanup_cmd);
160
161   meta_close();
162   exit(rc);
163 }
164
165 static void
166 flush_line(void)
167 {
168   if (partial_line)
169     fputc('\n', stderr);
170   partial_line = 0;
171 }
172
173 /* Report an error of the sandbox itself */
174 static void NONRET __attribute__((format(printf,1,2)))
175 die(char *msg, ...)
176 {
177   va_list args;
178   va_start(args, msg);
179   char buf[1024];
180   int n = vsnprintf(buf, sizeof(buf), msg, args);
181
182   if (write_errors_to_fd)
183     {
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);
187       exit(2);
188     }
189
190   // Otherwise, we in the box keeper process, so we report errors normally
191   flush_line();
192   meta_printf("status:XX\nmessage:%s\n", buf);
193   fputs(buf, stderr);
194   fputc('\n', stderr);
195   box_exit(2);
196 }
197
198 /* Report an error of the program inside the sandbox */
199 static void NONRET __attribute__((format(printf,1,2)))
200 err(char *msg, ...)
201 {
202   va_list args;
203   va_start(args, msg);
204   flush_line();
205   if (msg[0] && msg[1] && msg[2] == ':' && msg[3] == ' ')
206     {
207       meta_printf("status:%c%c\n", msg[0], msg[1]);
208       msg += 4;
209     }
210   char buf[1024];
211   vsnprintf(buf, sizeof(buf), msg, args);
212   meta_printf("message:%s\n", buf);
213   fputs(buf, stderr);
214   fputc('\n', stderr);
215   box_exit(1);
216 }
217
218 /* Write a message, but only if in verbose mode */
219 static void __attribute__((format(printf,1,2)))
220 msg(char *msg, ...)
221 {
222   va_list args;
223   va_start(args, msg);
224   if (verbose)
225     {
226       int len = strlen(msg);
227       if (len > 0)
228         partial_line = (msg[len-1] != '\n');
229       vfprintf(stderr, msg, args);
230       fflush(stderr);
231     }
232   va_end(args);
233 }
234
235 /*** Utility functions ***/
236
237 static void *
238 xmalloc(size_t size)
239 {
240   void *p = malloc(size);
241   if (!p)
242     die("Out of memory");
243   return p;
244 }
245
246 static char *
247 xstrdup(char *str)
248 {
249   char *p = strdup(str);
250   if (!p)
251     die("Out of memory");
252   return p;
253 }
254
255 static int dir_exists(char *path)
256 {
257   struct stat st;
258   return (stat(path, &st) >= 0 && S_ISDIR(st.st_mode));
259 }
260
261 /*** Environment rules ***/
262
263 struct env_rule {
264   char *var;                    // Variable to match
265   char *val;                    // ""=clear, NULL=inherit
266   int var_len;
267   struct env_rule *next;
268 };
269
270 static struct env_rule *first_env_rule;
271 static struct env_rule **last_env_rule = &first_env_rule;
272
273 static struct env_rule default_env_rules[] = {
274   { "LIBC_FATAL_STDERR_", "1" }
275 };
276
277 static int
278 set_env_action(char *a0)
279 {
280   struct env_rule *r = xmalloc(sizeof(*r) + strlen(a0) + 1);
281   char *a = (char *)(r+1);
282   strcpy(a, a0);
283
284   char *sep = strchr(a, '=');
285   if (sep == a)
286     return 0;
287   r->var = a;
288   if (sep)
289     {
290       *sep++ = 0;
291       r->val = sep;
292     }
293   else
294     r->val = NULL;
295   *last_env_rule = r;
296   last_env_rule = &r->next;
297   r->next = NULL;
298   return 1;
299 }
300
301 static int
302 match_env_var(char *env_entry, struct env_rule *r)
303 {
304   if (strncmp(env_entry, r->var, r->var_len))
305     return 0;
306   return (env_entry[r->var_len] == '=');
307 }
308
309 static void
310 apply_env_rule(char **env, int *env_sizep, struct env_rule *r)
311 {
312   // First remove the variable if already set
313   int pos = 0;
314   while (pos < *env_sizep && !match_env_var(env[pos], r))
315     pos++;
316   if (pos < *env_sizep)
317     {
318       (*env_sizep)--;
319       env[pos] = env[*env_sizep];
320       env[*env_sizep] = NULL;
321     }
322
323   // What is the new value?
324   char *new;
325   if (r->val)
326     {
327       if (!r->val[0])
328         return;
329       new = xmalloc(r->var_len + 1 + strlen(r->val) + 1);
330       sprintf(new, "%s=%s", r->var, r->val);
331     }
332   else
333     {
334       pos = 0;
335       while (environ[pos] && !match_env_var(environ[pos], r))
336         pos++;
337       if (!(new = environ[pos]))
338         return;
339     }
340
341   // Add it at the end of the array
342   env[(*env_sizep)++] = new;
343   env[*env_sizep] = NULL;
344 }
345
346 static char **
347 setup_environment(void)
348 {
349   // Link built-in rules with user rules
350   for (int i=ARRAY_SIZE(default_env_rules)-1; i >= 0; i--)
351     {
352       default_env_rules[i].next = first_env_rule;
353       first_env_rule = &default_env_rules[i];
354     }
355
356   // Scan the original environment
357   char **orig_env = environ;
358   int orig_size = 0;
359   while (orig_env[orig_size])
360     orig_size++;
361
362   // For each rule, reserve one more slot and calculate length
363   int num_rules = 0;
364   for (struct env_rule *r = first_env_rule; r; r=r->next)
365     {
366       num_rules++;
367       r->var_len = strlen(r->var);
368     }
369
370   // Create a new environment
371   char **env = xmalloc((orig_size + num_rules + 1) * sizeof(char *));
372   int size;
373   if (pass_environ)
374     {
375       memcpy(env, environ, orig_size * sizeof(char *));
376       size = orig_size;
377     }
378   else
379     size = 0;
380   env[size] = NULL;
381
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);
385
386   // Return the new env and pass some gossip
387   if (verbose > 1)
388     {
389       fprintf(stderr, "Passing environment:\n");
390       for (int i=0; env[i]; i++)
391         fprintf(stderr, "\t%s\n", env[i]);
392     }
393   return env;
394 }
395
396 /*** Directory rules ***/
397
398 struct dir_rule {
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;
403 };
404
405 enum dir_rule_flags {
406   DIR_FLAG_RW = 1,
407   DIR_FLAG_NOEXEC = 2,
408   DIR_FLAG_FS = 4,
409   DIR_FLAG_MAYBE = 8,
410   DIR_FLAG_DEV = 16,
411 };
412
413 static const char * const dir_flag_names[] = { "rw", "noexec", "fs", "maybe", "dev" };
414
415 static struct dir_rule *first_dir_rule;
416 static struct dir_rule **last_dir_rule = &first_dir_rule;
417
418 static int add_dir_rule(char *in, char *out, unsigned int flags)
419 {
420   // Make sure that "in" is relative
421   while (in[0] == '/')
422     in++;
423   if (!*in)
424     return 0;
425
426   // Check "out"
427   if (flags & DIR_FLAG_FS)
428     {
429       if (!out || out[0] == '/')
430         return 0;
431     }
432   else
433     {
434       if (out && out[0] != '/' && strncmp(out, "./", 2))
435         return 0;
436     }
437
438   // Override an existing rule
439   struct dir_rule *r;
440   for (r = first_dir_rule; r; r = r->next)
441     if (!strcmp(r->inside, in))
442       break;
443
444   // Add a new rule
445   if (!r)
446     {
447       r = xmalloc(sizeof(*r));
448       r->inside = in;
449       *last_dir_rule = r;
450       last_dir_rule = &r->next;
451       r->next = NULL;
452     }
453   r->outside = out;
454   r->flags = flags;
455   return 1;
456 }
457
458 static unsigned int parse_dir_option(char *opt)
459 {
460   for (unsigned int i = 0; i < ARRAY_SIZE(dir_flag_names); i++)
461     if (!strcmp(opt, dir_flag_names[i]))
462       return 1U << i;
463   die("Unknown directory option %s", opt);
464 }
465
466 static int set_dir_action(char *arg)
467 {
468   arg = xstrdup(arg);
469
470   char *colon = strchr(arg, ':');
471   unsigned int flags = 0;
472   while (colon)
473     {
474       *colon++ = 0;
475       char *next = strchr(colon, ':');
476       if (next)
477         *next = 0;
478       flags |= parse_dir_option(colon);
479       colon = next;
480     }
481
482   char *eq = strchr(arg, '=');
483   if (eq)
484     {
485       *eq++ = 0;
486       return add_dir_rule(arg, (*eq ? eq : NULL), flags);
487     }
488   else
489     {
490       char *out = xmalloc(1 + strlen(arg) + 1);
491       sprintf(out, "/%s", arg);
492       return add_dir_rule(arg, out, flags);
493     }
494 }
495
496 static void init_dir_rules(void)
497 {
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");
505 }
506
507 static void make_dir(char *path)
508 {
509   char *sep = (path[0] == '/' ? path+1 : path);
510
511   for (;;)
512     {
513       sep = strchr(sep, '/');
514       if (sep)
515         *sep = 0;
516
517       if (!dir_exists(path) && mkdir(path, 0777) < 0)
518         die("Cannot create directory %s: %m\n", path);
519
520       if (!sep)
521         return;
522       *sep++ = '/';
523     }
524 }
525
526 static void apply_dir_rules(void)
527 {
528   for (struct dir_rule *r = first_dir_rule; r; r=r->next)
529     {
530       char *in = r->inside;
531       char *out = r->outside;
532       if (!out)
533         {
534           msg("Not binding anything on %s\n", r->inside);
535           continue;
536         }
537
538       if ((r->flags & DIR_FLAG_MAYBE) && !dir_exists(out))
539         {
540           msg("Not binding %s on %s (does not exist)\n", out, r->inside);
541           continue;
542         }
543
544       char root_in[1024];
545       snprintf(root_in, sizeof(root_in), "root/%s", in);
546       make_dir(root_in);
547
548       unsigned long mount_flags = 0;
549       if (!(r->flags & DIR_FLAG_RW))
550         mount_flags |= MS_RDONLY;
551       if (r->flags & DIR_FLAG_NOEXEC)
552         mount_flags |= MS_NOEXEC;
553       if (!(r->flags & DIR_FLAG_DEV))
554         mount_flags |= MS_NODEV;
555
556       if (r->flags & DIR_FLAG_FS)
557         {
558           msg("Mounting %s on %s (flags %lx)\n", out, in, mount_flags);
559           if (mount("none", root_in, out, mount_flags, "") < 0)
560             die("Cannot mount %s on %s: %m", out, in);
561         }
562       else
563         {
564           mount_flags |= MS_BIND | MS_NOSUID;
565           msg("Binding %s on %s (flags %lx)\n", out, in, mount_flags);
566           // Most mount flags need remount to work
567           if (mount(out, root_in, "none", mount_flags, "") < 0 ||
568               mount(out, root_in, "none", MS_REMOUNT | mount_flags, "") < 0)
569             die("Cannot mount %s on %s: %m", out, in);
570         }
571     }
572 }
573
574 /*** Control groups ***/
575
576 static char cg_path[256];
577
578 #define CG_BUFSIZE 1024
579
580 static int
581 cg_read(char *attr, char *buf)
582 {
583   int maybe = 0;
584   if (attr[0] == '?')
585     {
586       attr++;
587       maybe = 1;
588     }
589
590   char path[256];
591   snprintf(path, sizeof(path), "%s/%s", cg_path, attr);
592
593   int fd = open(path, O_RDONLY);
594   if (fd < 0)
595     {
596       if (maybe)
597         return 0;
598       die("Cannot read %s: %m", path);
599     }
600
601   int n = read(fd, buf, CG_BUFSIZE);
602   if (n < 0)
603     die("Cannot read %s: %m", path);
604   if (n >= CG_BUFSIZE - 1)
605     die("Attribute %s too long", path);
606   if (n > 0 && buf[n-1] == '\n')
607     n--;
608   buf[n] = 0;
609
610   if (verbose > 1)
611     msg("CG: Read %s = %s\n", attr, buf);
612
613   close(fd);
614   return 1;
615 }
616
617 static void __attribute__((format(printf,2,3)))
618 cg_write(char *attr, char *fmt, ...)
619 {
620   va_list args;
621   va_start(args, fmt);
622
623   char buf[CG_BUFSIZE];
624   int n = vsnprintf(buf, sizeof(buf), fmt, args);
625   if (n >= CG_BUFSIZE)
626     die("cg_writef: Value for attribute %s is too long", attr);
627
628   if (verbose > 1)
629     msg("CG: Write %s = %s", attr, buf);
630
631   char path[256];
632   snprintf(path, sizeof(path), "%s/%s", cg_path, attr);
633
634   int fd = open(path, O_WRONLY | O_TRUNC);
635   if (fd < 0)
636     die("Cannot write %s: %m", path);
637
638   int written = write(fd, buf, n);
639   if (written < 0)
640     die("Cannot set %s to %s: %m", path, buf);
641   if (written != n)
642     die("Short write to %s (%d out of %d bytes)", path, written, n);
643
644   close(fd);
645   va_end(args);
646 }
647
648 static void
649 cg_init(void)
650 {
651   if (!cg_enable)
652     return;
653
654   char *cg_root = CONFIG_ISOLATE_CGROUP_ROOT;
655   if (!dir_exists(cg_root))
656     die("Control group filesystem at %s not mounted", cg_root);
657
658   snprintf(cg_path, sizeof(cg_path), "%s/box-%d", cg_root, box_id);
659   msg("Using control group %s\n", cg_path);
660 }
661
662 static void
663 cg_prepare(void)
664 {
665   if (!cg_enable)
666     return;
667
668   struct stat st;
669   char buf[CG_BUFSIZE];
670
671   if (stat(cg_path, &st) >= 0 || errno != ENOENT)
672     {
673       msg("Control group %s already exists, trying to empty it.\n", cg_path);
674       if (rmdir(cg_path) < 0)
675         die("Failed to reset control group %s: %m", cg_path);
676     }
677
678   if (mkdir(cg_path, 0777) < 0)
679     die("Failed to create control group %s: %m", cg_path);
680
681   // If cpuset module is enabled, copy allowed cpus and memory nodes from parent group
682   if (cg_read("?../cpuset.cpus", buf))
683     cg_write("cpuset.cpus", "%s", buf);
684   if (cg_read("?../cpuset.mems", buf))
685     cg_write("cpuset.mems", "%s", buf);
686 }
687
688 static void
689 cg_enter(void)
690 {
691   if (!cg_enable)
692     return;
693
694   msg("Entering control group %s\n", cg_path);
695
696   struct stat st;
697   if (stat(cg_path, &st) < 0)
698     die("Control group %s does not exist: %m", cg_path);
699
700   if (cg_memory_limit)
701     {
702       cg_write("memory.limit_in_bytes", "%lld\n", (long long) cg_memory_limit << 10);
703       cg_write("memory.memsw.limit_in_bytes", "%lld\n", (long long) cg_memory_limit << 10);
704     }
705
706   if (cg_timing)
707     cg_write("cpuacct.usage", "0\n");
708
709   cg_write("tasks", "%d\n", (int) getpid());
710 }
711
712 static int
713 cg_get_run_time_ms(void)
714 {
715   if (!cg_enable)
716     return 0;
717
718   char buf[CG_BUFSIZE];
719   cg_read("cpuacct.usage", buf);
720   unsigned long long ns = atoll(buf);
721   return ns / 1000000;
722 }
723
724 static void
725 cg_stats(void)
726 {
727   if (!cg_enable)
728     return;
729
730   char buf[CG_BUFSIZE];
731
732   // Memory usage statistics
733   unsigned long long mem=0, memsw=0;
734   if (cg_read("?memory.max_usage_in_bytes", buf))
735     mem = atoll(buf);
736   if (cg_read("?memory.memsw.max_usage_in_bytes", buf))
737     {
738       memsw = atoll(buf);
739       if (memsw > mem)
740         mem = memsw;
741     }
742   if (mem)
743     meta_printf("cg-mem:%lld\n", mem >> 10);
744 }
745
746 static void
747 cg_remove(void)
748 {
749   char buf[CG_BUFSIZE];
750
751   if (!cg_enable)
752     return;
753
754   cg_read("tasks", buf);
755   if (buf[0])
756     die("Some tasks left in control group %s, failed to remove it", cg_path);
757
758   if (rmdir(cg_path) < 0)
759     die("Cannot remove control group %s: %m", cg_path);
760 }
761
762 /*** The keeper process ***/
763
764 static void
765 signal_alarm(int unused UNUSED)
766 {
767   /* Time limit checks are synchronous, so we only schedule them there. */
768   timer_tick = 1;
769   alarm(1);
770 }
771
772 static void
773 signal_int(int unused UNUSED)
774 {
775   /* Interrupts are fatal, so no synchronization requirements. */
776   meta_printf("exitsig:%d\n", SIGINT);
777   err("SG: Interrupted");
778 }
779
780 #define PROC_BUF_SIZE 4096
781 static void
782 read_proc_file(char *buf, char *name, int *fdp)
783 {
784   int c;
785
786   if (!*fdp)
787     {
788       sprintf(buf, "/proc/%d/%s", (int) box_pid, name);
789       *fdp = open(buf, O_RDONLY);
790       if (*fdp < 0)
791         die("open(%s): %m", buf);
792     }
793   lseek(*fdp, 0, SEEK_SET);
794   if ((c = read(*fdp, buf, PROC_BUF_SIZE-1)) < 0)
795     die("read on /proc/$pid/%s: %m", name);
796   if (c >= PROC_BUF_SIZE-1)
797     die("/proc/$pid/%s too long", name);
798   buf[c] = 0;
799 }
800
801 static int
802 get_wall_time_ms(void)
803 {
804   struct timeval now, wall;
805   gettimeofday(&now, NULL);
806   timersub(&now, &start_time, &wall);
807   return wall.tv_sec*1000 + wall.tv_usec/1000;
808 }
809
810 static int
811 get_run_time_ms(struct rusage *rus)
812 {
813   if (cg_timing)
814     return cg_get_run_time_ms();
815
816   if (rus)
817     {
818       struct timeval total;
819       timeradd(&rus->ru_utime, &rus->ru_stime, &total);
820       return total.tv_sec*1000 + total.tv_usec/1000;
821     }
822
823   char buf[PROC_BUF_SIZE], *x;
824   int utime, stime;
825   static int proc_stat_fd;
826
827   read_proc_file(buf, "stat", &proc_stat_fd);
828   x = buf;
829   while (*x && *x != ' ')
830     x++;
831   while (*x == ' ')
832     x++;
833   if (*x++ != '(')
834     die("proc stat syntax error 1");
835   while (*x && (*x != ')' || x[1] != ' '))
836     x++;
837   while (*x == ')' || *x == ' ')
838     x++;
839   if (sscanf(x, "%*c %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %d %d", &utime, &stime) != 2)
840     die("proc stat syntax error 2");
841
842   return (utime + stime) * 1000 / ticks_per_sec;
843 }
844
845 static void
846 check_timeout(void)
847 {
848   if (wall_timeout)
849     {
850       int wall_ms = get_wall_time_ms();
851       if (wall_ms > wall_timeout)
852         err("TO: Time limit exceeded (wall clock)");
853       if (verbose > 1)
854         fprintf(stderr, "[wall time check: %d msec]\n", wall_ms);
855     }
856   if (timeout)
857     {
858       int ms = get_run_time_ms(NULL);
859       if (verbose > 1)
860         fprintf(stderr, "[time check: %d msec]\n", ms);
861       if (ms > timeout && ms > extra_timeout)
862         err("TO: Time limit exceeded");
863     }
864 }
865
866 static void
867 box_keeper(void)
868 {
869   read_errors_from_fd = error_pipes[0];
870   close(error_pipes[1]);
871
872   struct sigaction sa;
873   bzero(&sa, sizeof(sa));
874   sa.sa_handler = signal_int;
875   sigaction(SIGINT, &sa, NULL);
876
877   gettimeofday(&start_time, NULL);
878   ticks_per_sec = sysconf(_SC_CLK_TCK);
879   if (ticks_per_sec <= 0)
880     die("Invalid ticks_per_sec!");
881
882   if (timeout || wall_timeout)
883     {
884       sa.sa_handler = signal_alarm;
885       sigaction(SIGALRM, &sa, NULL);
886       alarm(1);
887     }
888
889   for(;;)
890     {
891       struct rusage rus;
892       int stat;
893       pid_t p;
894       if (timer_tick)
895         {
896           check_timeout();
897           timer_tick = 0;
898         }
899       p = wait4(box_pid, &stat, 0, &rus);
900       if (p < 0)
901         {
902           if (errno == EINTR)
903             continue;
904           die("wait4: %m");
905         }
906       if (p != box_pid)
907         die("wait4: unknown pid %d exited!", p);
908       box_pid = 0;
909
910       // Check error pipe if there is an internal error passed from inside the box
911       char interr[1024];
912       int n = read(read_errors_from_fd, interr, sizeof(interr) - 1);
913       if (n > 0)
914         {
915           interr[n] = 0;
916           die("%s", interr);
917         }
918
919       if (WIFEXITED(stat))
920         {
921           final_stats(&rus);
922           if (WEXITSTATUS(stat))
923             {
924               meta_printf("exitcode:%d\n", WEXITSTATUS(stat));
925               err("RE: Exited with error status %d", WEXITSTATUS(stat));
926             }
927           if (timeout && total_ms > timeout)
928             err("TO: Time limit exceeded");
929           if (wall_timeout && wall_ms > wall_timeout)
930             err("TO: Time limit exceeded (wall clock)");
931           flush_line();
932           fprintf(stderr, "OK (%d.%03d sec real, %d.%03d sec wall)\n",
933               total_ms/1000, total_ms%1000,
934               wall_ms/1000, wall_ms%1000);
935           box_exit(0);
936         }
937       else if (WIFSIGNALED(stat))
938         {
939           meta_printf("exitsig:%d\n", WTERMSIG(stat));
940           final_stats(&rus);
941           err("SG: Caught fatal signal %d", WTERMSIG(stat));
942         }
943       else if (WIFSTOPPED(stat))
944         {
945           meta_printf("exitsig:%d\n", WSTOPSIG(stat));
946           final_stats(&rus);
947           err("SG: Stopped by signal %d", WSTOPSIG(stat));
948         }
949       else
950         die("wait4: unknown status %x, giving up!", stat);
951     }
952 }
953
954 /*** The process running inside the box ***/
955
956 static void
957 setup_root(void)
958 {
959   if (mkdir("root", 0750) < 0 && errno != EEXIST)
960     die("mkdir('root'): %m");
961
962   if (mount("none", "root", "tmpfs", 0, "mode=755") < 0)
963     die("Cannot mount root ramdisk: %m");
964
965   apply_dir_rules();
966
967   if (chroot("root") < 0)
968     die("Chroot failed: %m");
969
970   if (chdir("root/box") < 0)
971     die("Cannot change current directory: %m");
972 }
973
974 static void
975 setup_credentials(void)
976 {
977   if (setresgid(box_gid, box_gid, box_gid) < 0)
978     die("setresgid: %m");
979   if (setgroups(0, NULL) < 0)
980     die("setgroups: %m");
981   if (setresuid(box_uid, box_uid, box_uid) < 0)
982     die("setresuid: %m");
983   setpgrp();
984 }
985
986 static void
987 setup_fds(void)
988 {
989   if (redir_stdin)
990     {
991       close(0);
992       if (open(redir_stdin, O_RDONLY) != 0)
993         die("open(\"%s\"): %m", redir_stdin);
994     }
995   if (redir_stdout)
996     {
997       close(1);
998       if (open(redir_stdout, O_WRONLY | O_CREAT | O_TRUNC, 0666) != 1)
999         die("open(\"%s\"): %m", redir_stdout);
1000     }
1001   if (redir_stderr)
1002     {
1003       close(2);
1004       if (open(redir_stderr, O_WRONLY | O_CREAT | O_TRUNC, 0666) != 2)
1005         die("open(\"%s\"): %m", redir_stderr);
1006     }
1007   else
1008     dup2(1, 2);
1009 }
1010
1011 static void
1012 setup_rlim(const char *res_name, int res, rlim_t limit)
1013 {
1014   struct rlimit rl = { .rlim_cur = limit, .rlim_max = limit };
1015   if (setrlimit(res, &rl) < 0)
1016     die("setrlimit(%s, %jd)", res_name, (intmax_t) limit);
1017 }
1018
1019 static void
1020 setup_rlimits(void)
1021 {
1022 #define RLIM(res, val) setup_rlim("RLIMIT_" #res, RLIMIT_##res, val)
1023
1024   if (memory_limit)
1025     RLIM(AS, memory_limit * 1024);
1026
1027   RLIM(STACK, (stack_limit ? (rlim_t)stack_limit * 1024 : RLIM_INFINITY));
1028   RLIM(NOFILE, 64);
1029   RLIM(MEMLOCK, 0);
1030
1031   if (max_processes)
1032     RLIM(NPROC, max_processes);
1033
1034 #undef RLIM
1035 }
1036
1037 static int
1038 box_inside(void *arg)
1039 {
1040   char **args = arg;
1041   write_errors_to_fd = error_pipes[1];
1042   close(error_pipes[0]);
1043
1044   cg_enter();
1045   setup_root();
1046   setup_credentials();
1047   setup_fds();
1048   setup_rlimits();
1049   char **env = setup_environment();
1050
1051   execve(args[0], args, env);
1052   die("execve(\"%s\"): %m", args[0]);
1053 }
1054
1055 static void
1056 box_init(void)
1057 {
1058   if (box_id < 0 || box_id >= CONFIG_ISOLATE_NUM_BOXES)
1059     die("Sandbox ID out of range (allowed: 0-%d)", CONFIG_ISOLATE_NUM_BOXES-1);
1060   box_uid = CONFIG_ISOLATE_FIRST_UID + box_id;
1061   box_gid = CONFIG_ISOLATE_FIRST_GID + box_id;
1062
1063   snprintf(box_dir, sizeof(box_dir), "%s/%d", CONFIG_ISOLATE_BOX_DIR, box_id);
1064   make_dir(box_dir);
1065   if (chdir(box_dir) < 0)
1066     die("chdir(%s): %m", box_dir);
1067 }
1068
1069 /*** Commands ***/
1070
1071 static void
1072 init(void)
1073 {
1074   msg("Preparing sandbox directory\n");
1075   xsystem("rm -rf box");
1076   if (mkdir("box", 0700) < 0)
1077     die("Cannot create box: %m");
1078   if (chown("box", orig_uid, orig_gid) < 0)
1079     die("Cannot chown box: %m");
1080
1081   cg_prepare();
1082
1083   puts(box_dir);
1084 }
1085
1086 static void
1087 cleanup(void)
1088 {
1089   if (!dir_exists("box"))
1090     die("Box directory not found, there isn't anything to clean up");
1091
1092   msg("Deleting sandbox directory\n");
1093   xsystem("rm -rf box");
1094   cg_remove();
1095 }
1096
1097 static void
1098 run(char **argv)
1099 {
1100   if (!dir_exists("box"))
1101     die("Box directory not found, did you run `isolate --init'?");
1102
1103   char cmd[256];
1104   snprintf(cmd, sizeof(cmd), "chown -R %d.%d box", box_uid, box_gid);
1105   xsystem(cmd);
1106   snprintf(cleanup_cmd, sizeof(cleanup_cmd), "chown -R %d.%d box", orig_uid, orig_gid);
1107
1108   if (pipe(error_pipes) < 0)
1109     die("pipe: %m");
1110   for (int i=0; i<2; i++)
1111     if (fcntl(error_pipes[i], F_SETFD, fcntl(error_pipes[i], F_GETFD) | FD_CLOEXEC) < 0 ||
1112         fcntl(error_pipes[i], F_SETFL, fcntl(error_pipes[i], F_GETFL) | O_NONBLOCK) < 0)
1113       die("fcntl on pipe: %m");
1114
1115   box_pid = clone(
1116     box_inside,                 // Function to execute as the body of the new process
1117     argv,                       // Pass our stack
1118     SIGCHLD | CLONE_NEWIPC | CLONE_NEWNET | CLONE_NEWNS | CLONE_NEWPID,
1119     argv);                      // Pass the arguments
1120   if (box_pid < 0)
1121     die("clone: %m");
1122   if (!box_pid)
1123     die("clone returned 0");
1124   box_keeper();
1125 }
1126
1127 static void
1128 show_version(void)
1129 {
1130   printf("Process isolator 1.0\n");
1131   printf("(c) 2012 Martin Mares and Bernard Blackham\n");
1132   printf("\nCompile-time configuration:\n");
1133   printf("Sandbox directory: %s\n", CONFIG_ISOLATE_BOX_DIR);
1134   printf("Sandbox credentials: uid=%u-%u gid=%u-%u\n",
1135     CONFIG_ISOLATE_FIRST_UID,
1136     CONFIG_ISOLATE_FIRST_UID + CONFIG_ISOLATE_NUM_BOXES - 1,
1137     CONFIG_ISOLATE_FIRST_GID,
1138     CONFIG_ISOLATE_FIRST_GID + CONFIG_ISOLATE_NUM_BOXES - 1);
1139 }
1140
1141 /*** Options ***/
1142
1143 static void
1144 usage(void)
1145 {
1146   fprintf(stderr, "Invalid arguments!\n");
1147   printf("\
1148 Usage: isolate [<options>] <command>\n\
1149 \n\
1150 Options:\n\
1151 -b, --box-id=<id>\tWhen multiple sandboxes are used in parallel, each must get a unique ID\n\
1152 -c, --cg[=<parent>]\tPut process in a control group (optionally a sub-group of <parent>)\n\
1153     --cg-mem=<size>\tLimit memory usage of the control group to <size> KB\n\
1154     --cg-timing\t\tTime limits affects total run time of the control group\n\
1155 -d, --dir=<dir>\t\tMake a directory <dir> visible inside the sandbox\n\
1156     --dir=<in>=<out>\tMake a directory <out> outside visible as <in> inside\n\
1157     --dir=<in>=\t\tDelete a previously defined directory rule (even a default one)\n\
1158     --dir=...:<opt>\tSpecify options for a rule:\n\
1159 \t\t\t\tdev\tAllow access to special files\n\
1160 \t\t\t\tfs\tMount a filesystem (e.g., --dir=/proc:proc:fs)\n\
1161 \t\t\t\tmaybe\tSkip the rule if <out> does not exist\n\
1162 \t\t\t\tnoexec\tDo not allow execution of binaries\n\
1163 \t\t\t\trw\tAllow read-write access\n\
1164 -E, --env=<var>\t\tInherit the environment variable <var> from the parent process\n\
1165 -E, --env=<var>=<val>\tSet the environment variable <var> to <val>; unset it if <var> is empty\n\
1166 -x, --extra-time=<time>\tSet extra timeout, before which a timing-out program is not yet killed,\n\
1167 \t\t\tso that its real execution time is reported (seconds, fractions allowed)\n\
1168 -e, --full-env\t\tInherit full environment of the parent process\n\
1169 -m, --mem=<size>\tLimit address space to <size> KB\n\
1170 -M, --meta=<file>\tOutput process information to <file> (name:value)\n\
1171 -k, --stack=<size>\tLimit stack size to <size> KB (default: 0=unlimited)\n\
1172 -r, --stderr=<file>\tRedirect stderr to <file>\n\
1173 -i, --stdin=<file>\tRedirect stdin from <file>\n\
1174 -o, --stdout=<file>\tRedirect stdout to <file>\n\
1175 -p, --processes[=<max>]\tEnable multiple processes (at most <max> of them); needs --cg\n\
1176 -t, --time=<time>\tSet run time limit (seconds, fractions allowed)\n\
1177 -v, --verbose\t\tBe verbose (use multiple times for even more verbosity)\n\
1178 -w, --wall-time=<time>\tSet wall clock time limit (seconds, fractions allowed)\n\
1179 \n\
1180 Commands:\n\
1181     --init\t\tInitialize sandbox (and its control group when --cg is used)\n\
1182     --run -- <cmd> ...\tRun given command within sandbox\n\
1183     --cleanup\t\tClean up sandbox\n\
1184     --version\t\tDisplay program version and configuration\n\
1185 ");
1186   exit(2);
1187 }
1188
1189 enum opt_code {
1190   OPT_INIT = 256,
1191   OPT_RUN,
1192   OPT_CLEANUP,
1193   OPT_VERSION,
1194   OPT_CG_MEM,
1195   OPT_CG_TIMING,
1196 };
1197
1198 static const char short_opts[] = "c:d:eE:i:k:m:M:o:p::r:t:vw:x:";
1199
1200 static const struct option long_opts[] = {
1201   { "box-id",           1, NULL, 'b' },
1202   { "cg",               1, NULL, 'c' },
1203   { "cg-mem",           1, NULL, OPT_CG_MEM },
1204   { "cg-timing",        0, NULL, OPT_CG_TIMING },
1205   { "cleanup",          0, NULL, OPT_CLEANUP },
1206   { "dir",              1, NULL, 'd' },
1207   { "env",              1, NULL, 'E' },
1208   { "extra-time",       1, NULL, 'x' },
1209   { "full-env",         0, NULL, 'e' },
1210   { "init",             0, NULL, OPT_INIT },
1211   { "mem",              1, NULL, 'm' },
1212   { "meta",             1, NULL, 'M' },
1213   { "processes",        2, NULL, 'p' },
1214   { "run",              0, NULL, OPT_RUN },
1215   { "stack",            1, NULL, 'k' },
1216   { "stderr",           1, NULL, 'r' },
1217   { "stdin",            1, NULL, 'i' },
1218   { "stdout",           1, NULL, 'o' },
1219   { "time",             1, NULL, 't' },
1220   { "verbose",          0, NULL, 'v' },
1221   { "version",          0, NULL, OPT_VERSION },
1222   { "wall-time",        1, NULL, 'w' },
1223   { NULL,               0, NULL, 0 }
1224 };
1225
1226 int
1227 main(int argc, char **argv)
1228 {
1229   int c;
1230   enum opt_code mode = 0;
1231
1232   init_dir_rules();
1233
1234   while ((c = getopt_long(argc, argv, short_opts, long_opts, NULL)) >= 0)
1235     switch (c)
1236       {
1237       case 'b':
1238         box_id = atoi(optarg);
1239         break;
1240       case 'c':
1241         cg_enable = 1;
1242         break;
1243       case 'd':
1244         if (!set_dir_action(optarg))
1245           usage();
1246         break;
1247       case 'e':
1248         pass_environ = 1;
1249         break;
1250       case 'E':
1251         if (!set_env_action(optarg))
1252           usage();
1253         break;
1254       case 'k':
1255         stack_limit = atoi(optarg);
1256         break;
1257       case 'i':
1258         redir_stdin = optarg;
1259         break;
1260       case 'm':
1261         memory_limit = atoi(optarg);
1262         break;
1263       case 'M':
1264         meta_open(optarg);
1265         break;
1266       case 'o':
1267         redir_stdout = optarg;
1268         break;
1269       case 'p':
1270         if (optarg)
1271           max_processes = atoi(optarg);
1272         else
1273           max_processes = 0;
1274         break;
1275       case 'r':
1276         redir_stderr = optarg;
1277         break;
1278       case 't':
1279         timeout = 1000*atof(optarg);
1280         break;
1281       case 'v':
1282         verbose++;
1283         break;
1284       case 'w':
1285         wall_timeout = 1000*atof(optarg);
1286         break;
1287       case 'x':
1288         extra_timeout = 1000*atof(optarg);
1289         break;
1290       case OPT_INIT:
1291       case OPT_RUN:
1292       case OPT_CLEANUP:
1293       case OPT_VERSION:
1294         mode = c;
1295         break;
1296       case OPT_CG_MEM:
1297         cg_memory_limit = atoi(optarg);
1298         break;
1299       case OPT_CG_TIMING:
1300         cg_timing = 1;
1301         break;
1302       default:
1303         usage();
1304       }
1305
1306   if (!mode)
1307     usage();
1308   if (mode == OPT_VERSION)
1309     {
1310       show_version();
1311       return 0;
1312     }
1313
1314   if (geteuid())
1315     die("Must be started as root");
1316   orig_uid = getuid();
1317   orig_gid = getgid();
1318
1319   umask(022);
1320   box_init();
1321   cg_init();
1322
1323   switch (mode)
1324     {
1325     case OPT_INIT:
1326       if (optind < argc)
1327         usage();
1328       init();
1329       break;
1330     case OPT_RUN:
1331       if (optind >= argc)
1332         usage();
1333       run(argv+optind);
1334       break;
1335     case OPT_CLEANUP:
1336       if (optind < argc)
1337         usage();
1338       cleanup();
1339       break;
1340     default:
1341       die("Internal error: mode mismatch");
1342     }
1343   exit(0);
1344 }