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 }