Proper preparing of kvm for jail

4 files changed, 392 insertions, 336 deletions

diff --git a/srcx/jkill.c b/srcx/jkill.c
index 4311ed8..953095e 100644
--- a/srcx/jkill.c
+++ b/srcx/jkill.c
@@ -84,15 +84,17 @@ static void usage_jail(const char* name);
 
 int main(int argc, char* argv[])
 {
-    int r, jid;
-    int ret = 0;
+    struct xprison* sxp = NULL;
+    struct xprison* xp = NULL;
+    size_t len;
+    int jid, r, ret = 0;
     pid_t child;
 
     /*
      * When running in a jail we do things slightly
      * differently, and accept different args
      */
-    if(running_in_jail())
+    if(running_in_jail() != 0)
     {
         parse_jail_opts(argc, argv);
 
@@ -114,17 +116,23 @@ int main(int argc, char* argv[])
         argc -= optind;
         argv += optind;
 
+        len = get_jail_sysctl(&sxp);
+
         /* For each jail */
         for(; argc > 0; argc--, argv++)
         {
-            jid = translate_jail_name(argv[0]);
-            if(jid == -1)
+            xp = find_jail(str, len, sxp);
+
+            if(xp == NULL)
             {
                 warnx("unknown jail host name: %s", argv[0]);
                 ret = 1;
                 continue;
             }
 
+            /* This makes sure we can use kvm funcs in jail */
+            kvm_prepare_jail(xp);
+
             /*
              * We fork and the child goes into the jail and
              * does the dirty work. Unless in debug mode where
@@ -141,6 +149,11 @@ int main(int argc, char* argv[])
             /* The child */
             case 0:
 #endif
+                jid = xp->pri_id;
+
+                /* Always free jail info before going into jail */
+                free_jail_sysctl(len, sxp);
+
                 if(jail_attach(jid) == -1)
                     err(1, "couldn't attach to jail");
 
@@ -164,6 +177,7 @@ int main(int argc, char* argv[])
             argv++;
         }
 
+        free_jail_sysctl(len, sxp);
         return ret;
     }
 }
@@ -304,7 +318,7 @@ static int kill_jail(const char* jail)
     int cmdargs = JAIL_RUN_CONSOLE;
 
     /* Open the kernel interface */
-    kd = open_kvm_handle(jail, errbuf);
+    kd = kvm_openfiles(_PATH_DEVNULL, _PATH_DEVNULL, NULL, O_RDONLY, errbuf);
     if(kd == NULL)
         errx(1, "couldn't connect to kernel: %s", errbuf);
 
diff --git a/srcx/jps.c b/srcx/jps.c
index 8b12b4a..867364d 100644
--- a/srcx/jps.c
+++ b/srcx/jps.c
@@ -61,9 +61,11 @@ static void run_jail_ps(int argc, char* argv[]);
 
 int main(int argc, char* argv[])
 {
-    int ch = 0;
+    struct xprison* sxp = NULL;
+    struct xprison* xp = NULL;
+    size_t len;
+    int jid, ch = 0;
     int simple = 0;
-    int jid = 0;
 
     while((ch = getopt(argc, argv, "i")) != -1)
     {
@@ -86,19 +88,29 @@ int main(int argc, char* argv[])
     if(argc == 0)
         usage();
 
-    if(running_in_jail())
+    if(running_in_jail() != 0)
         errx(1, "can't run from inside jail");
 
     /* Translate the jail name into an id if neccessary */
-    jid = translate_jail_name(argv[0]);
-    if(jid == -1)
+    len = get_jail_sysctl(&sxp);
+    xp = find_jail(argv[0], len, sxp);
+
+    if(xp == NULL)
         errx(1, "unknown jail host name: %s", argv[0]);
 
     argc--;
     argv++;
 
+    /* This makes sure we can use kvm funcs in jail */
+    kvm_prepare_jail(xp);
+
+    jid = xp->pr_id;
+
+    /* Always free jail info before going into jail */
+    free_jail_sysctl(len, sxp);
+
     /* Go into the jail */
-    if(jail_attach(jid) == -1)
+    if(jail_attach(xp->pr_id) == -1)
         err(1, "couldn't attach to jail");
 
     if(simple)
@@ -126,21 +138,12 @@ static void usage()
 
 static void run_jail_ps(int argc, char* argv[])
 {
-    char errbuf[_POSIX2_LINE_MAX];
     char** args;
-    kvm_t* kd;
     int i;
 
     if(!check_jail_command(NULL, "/bin/ps"))
         exit(1);
 
-    /* Make sure we can use kvm functionality here */
-    kd = open_kvm_handle(NULL, errbuf);
-    if(kd == NULL)
-        errx(1, "couldn't connect to kernel: %s", errbuf);
-
-    kvm_close(kd);
-
     /*
      * TODO: We need to purge down the environment here.
      * If the jail is in any way malicious or compromised
@@ -166,7 +169,7 @@ static void print_jail_ids()
     char errbuf[_POSIX2_LINE_MAX];
 
     /* Open kernel interface */
-    kd = open_kvm_handle(NULL, errbuf);
+    kd = kvm_openfiles(_PATH_DEVNULL, _PATH_DEVNULL, NULL, O_RDONLY, errbuf);
     if(kd == NULL)
         errx(1, "couldn't connect to kernel: %s", errbuf);
 
diff --git a/srcx/util.c b/srcx/util.c
index 31ee3bd..137ca24 100644
--- a/srcx/util.c
+++ b/srcx/util.c
@@ -61,149 +61,178 @@ extern char** environ;
 
 size_t get_jail_sysctl(struct xprison** ret)
 {
-  struct xprison* xp;
-  size_t len;
-  *ret = NULL;
+    struct xprison* xp;
+    size_t len;
+    *ret = NULL;
 
-  if(sysctlbyname("security.jail.list", NULL, &len, NULL, 0) == -1)
-    err(1, "couldn't list jails");
+    if(sysctlbyname("security.jail.list", NULL, &len, NULL, 0) == -1)
+      err(1, "couldn't list jails");
 
 retry:
 
-  if(len <= 0)
-    return 0;
+    if(len <= 0)
+        return 0;
 
-  xp = calloc(len, 1);
-  if(xp == NULL)
-    err(1, "out of memory");
+    xp = calloc(len, 1);
+    if(xp == NULL)
+        err(1, "out of memory");
 
-  if(sysctlbyname("security.jail.list", xp, &len, NULL, 0) == -1)
-  {
-    if(errno == ENOMEM)
+    if(sysctlbyname("security.jail.list", xp, &len, NULL, 0) == -1)
     {
-      free(xp);
-      goto retry;
+        if(errno == ENOMEM)
+        {
+            free(xp);
+            goto retry;
+        }
+
+        err(1, "couldn't list jails");
     }
 
-    err(1, "couldn't list jails");
-  }
+    if(len < sizeof(*xp) || len % sizeof(*xp) || xp->pr_version != XPRISON_VERSION)
+        errx(1, "kernel and userland out of sync");
 
-  if(len < sizeof(*xp) || len % sizeof(*xp) || xp->pr_version != XPRISON_VERSION)
-    errx(1, "kernel and userland out of sync");
+    *ret = xp;
+    return len / sizeof(*xp);
+}
 
-  *ret = xp;
-  return len / sizeof(*xp);
+void free_jail_sysctl(size_t len, struct xprison* xp)
+{
+    if(len == 0 || xp == NULL)
+        return;
+
+    /*
+     * An extra precaution to prevent leakage of information
+     * into the jail.
+     */
+
+    memset(xp, 0, sizeof(struct xprison) * len);
+    free(xp);
 }
 
-int translate_jail_name(const char* str)
+struct xprison* find_jail(const char* str, size_t len, struct xprison* xp)
 {
-  struct xprison* xp = NULL;
-  size_t len, i;
-  char* e;
-  int jid = -1;
+    int jid;
+    size_t i;
+    char* e;
+
+    if(len == 0 || xp == NULL)
+        return NULL;
 
-  len = get_jail_sysctl(&xp);
-  if(len == 0)
-    goto done;
+    jid = strtol(str, &e, 10);
 
-  jid = strtol(str, &e, 10);
+    /* If it was all a number ... */
+    if(!*e)
+    {
+        if(jid <= 0)
+            errx(1, "invalid jail id: %s", str);
 
-  /* If it was all a number ... */
-  if(!*e)
-  {
-    if(jid <= 0)
-      errx(1, "invalid jail id: %s", str);
+        /* Validate the number */
+        for(i = 0; i < len; i++)
+        {
+            if(jid == xp[i].pr_id)
+                return &(xp[i]);
+        }
+    }
 
-    /* Validate the number */
     for(i = 0; i < len; i++)
     {
-      if(jid == xp[i].pr_id)
-        goto done;
+        if(strcmp(xp[i].pr_host, str) == 0)
+            return &(xp[i]);
     }
 
-    jid = -1;
-  }
+    return NULL;
+}
 
-  jid = -1;
+int translate_jail_name(const char* str)
+{
+    struct xprison* sxp = NULL;
+    struct xprison* xp = NULL;
+    size_t len;
+    int jid = -1;
 
-  for(i = 0; i < len; i++)
-  {
-    if(strcmp(xp[i].pr_host, str) == 0)
+    len = get_jail_sysctl(&sxp);
+    if(sxp)
     {
-      jid = xp[i].pr_id;
-      break;
-    }
-  }
+        xp = find_jail(str, sxp);
+        if(xp != NULL)
+            jid = xp->pr_id;
 
-done:
-  if(xp)
-    free(xp);
+        free(sxp);
+    }
 
-  return jid;
+    return jid;
 }
 
-kvm_t* open_kvm_handle(const char* jail, char* errbuf)
+int kvm_prepare_jail(struct xprison* xp)
 {
-  /*
-   * Basically the kvm routines won't work in a jail unless there's
-   * a /dev/null device for us to use as the file names. If it's
-   * missing we have to create it.
-   */
-
-  struct stat sb;
-  int nodir = 0;
-  int nonull = 0;
-
-  if(stat(_PATH_DEVNULL, &sb) == -1)
-  {
-    if(errno == ENOTDIR)
-    {
-      nodir = 1;
-      nonull = 1;
-    }
+    /*
+     * Basically the kvm routines won't work in a jail unless there's
+     * a /dev/null device for us to use as the file names. If it's
+     * missing we have to create it.
+     */
+
+    struct stat sb;
+    char* path;
+    int nodir = 0;
+    int nonull = 0;
+
+    path = (char*)alloca(strlen(_PATH_DEVNULL) + 2 + strlen(xp->pr_path));
 
-    else if(errno == ENOENT)
+    strcpy(path, xp->pr_path);
+    strcat(path, _PATH_DEVNULL);
+
+    if(stat(path, &sb) == -1)
     {
-      nonull = 1;
+        if(errno == ENOTDIR)
+        {
+            nodir = 1;
+            nonull = 1;
+        }
+
+        else if(errno == ENOENT)
+        {
+            nonull = 1;
+        }
+
+        else
+        {
+            err(1, "couldn't stat file: %s", path);
+        }
     }
 
-    else
+    if(nodir)
     {
-      err(1, "%s%scouldn't stat file: %s", jail ? jail : "",
-                  jail ? ": " : "", _PATH_DEVNULL);
-    }
-  }
+        strcpy(path, xp->pr_path);
+        strcat(path, _PATH_DEV);
 
-  if(nodir)
-  {
-    warnx("%s%sthe %s directory doesn't exist in jail. creating...",
-         jail ? jail : "", jail ? ": " : "", _PATH_DEV);
+        warnx("the %s directory doesn't exist. creating...", path);
 
-    if(mkdir(_PATH_DEV, 0) == -1 ||
-       chmod(_PATH_DEV, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) == -1)
-    {
-      warn("%s%scouldn't create %s directory",
-           jail ? jail : "", jail ? ": " : "", _PATH_DEV);
-      nonull = 0;
+        if(mkdir(path, 0) == -1 ||
+           chmod(path, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) == -1)
+        {
+            warn("couldn't create %s directory", path);
+            return -1;
+        }
     }
-  }
 
-  if(nonull)
-  {
-    mode_t mode = 0666 | S_IFCHR;
-    dev_t dev = makedev(2, 2);
+    if(nonull)
+    {
+        mode_t mode = 0666 | S_IFCHR;
+        dev_t dev = makedev(2, 2);
+
+        strcpy(path, xp->pr_path);
+        strcat(path, _PATH_DEVNULL);
 
-    warnx("%s%sthe %s device doesn't exist in jail. creating...",
-         jail ? jail : "", jail ? ": " : "", _PATH_DEVNULL);
+        warnx("the %s device doesn't exist in jail. creating...", path);
 
-    if(mknod(_PATH_DEVNULL, mode, dev) == -1)
-    {
-      warn("%s%scouldn't create %s device",
-           jail ? jail : "", jail ? ": " : "", _PATH_DEVNULL);
+        if(mknod(path, mode, dev) == -1)
+        {
+            warn("couldn't create %s device", path);
+            return -1;
+        }
     }
-  }
 
-  return kvm_openfiles(_PATH_DEVNULL, _PATH_DEVNULL, NULL, O_RDONLY, errbuf);
+    return 0;
 }
 
 /*
@@ -215,119 +244,120 @@ kvm_t* open_kvm_handle(const char* jail, char* errbuf)
 
 int running_in_jail()
 {
-  int count;
-  kvm_t* kd = 0;
-  struct kinfo_proc* kp;
-  char errbuf[_POSIX2_LINE_MAX];
-  int  result = -1;
+    int count;
+    kvm_t* kd = 0;
+    struct kinfo_proc* kp;
+    int  result = -1;
 
-  kd = open_kvm_handle(NULL, errbuf);
-  if(kd == NULL)
-    errx(1, "couldn't connect to kernel: %s", errbuf);
+    kd = kvm_open(_PATH_DEVNULL, _PATH_DEVNULL, NULL, O_RDONLY, NULL);
+    if(kd == NULL)
+        return -1;
 
-  kp = kvm_getprocs(kd, KERN_PROC_PID, getpid(), &count);
-  if(kp == NULL)
-    errx(1, "couldn't list processes: %s", kvm_geterr(kd));
+    kp = kvm_getprocs(kd, KERN_PROC_PID, getpid(), &count);
 
-  result = (kp->ki_flag & P_JAILED) ? 1 : 0;
-  kvm_close(kd);
+    if(kp == NULL)
+        result = -1;
+    else
+        result = (kp->ki_flag & P_JAILED) ? 1 : 0;
+
+    kvm_close(kd);
 
-  return result;
+    return result;
 }
 
 
 int check_jail_command(const char* jail, const char* cmd)
 {
-  struct stat sb;
+    struct stat sb;
 
-  if(stat(cmd, &sb) == -1)
-  {
-    if(errno == EACCES || errno == ELOOP || errno == ENAMETOOLONG ||
-       errno == ENOENT || errno == ENOTDIR)
+    if(stat(cmd, &sb) == -1)
     {
-      warn("%s%scan't execute in jail: %s", jail ? jail : "",
-                jail ? ": " : "", cmd);
-      return 0;
-    }
+        if(errno == EACCES || errno == ELOOP || errno == ENAMETOOLONG ||
+           errno == ENOENT || errno == ENOTDIR)
+        {
+            warn("%s%scan't execute in jail: %s", jail ? jail : "",
+                 jail ? ": " : "", cmd);
+            return 0;
+        }
 
-    err(1, "%s%scouldn't stat file: %s", jail ? jail : "",
-                jail ? ": " : "", cmd);
-  }
+        err(1, "%s%scouldn't stat file: %s", jail ? jail : "",
+            jail ? ": " : "", cmd);
+    }
 
-  if(!(sb.st_mode & S_IFREG))
-  {
-    warnx("%s%snot a regular file: %s", jail ? jail : "",
+    if(!(sb.st_mode & S_IFREG))
+    {
+        warnx("%s%snot a regular file: %s", jail ? jail : "",
                 jail ? ": " : "", cmd);
-    return 0;
-  }
+        return 0;
+    }
 
-  if(sb.st_uid != 0)
-  {
-    warnx("%s%snot owned by root: %s", jail ? jail : "",
+    if(sb.st_uid != 0)
+    {
+        warnx("%s%snot owned by root: %s", jail ? jail : "",
                 jail ? ": " : "", cmd);
-    return 0;
-  }
+        return 0;
+    }
 
-  return 1;
+    return 1;
 }
 
 int run_overlay_command(const char* jail, const char* cmd, char* env[],
                         char* args[])
 {
-  if(args)
-    execve(cmd, args, env);
-  else
-    execle(cmd, cmd, NULL, env);
+    if(args)
+        execve(cmd, args, env);
+    else
+        execle(cmd, cmd, NULL, env);
 
-  warn("%s%serror executing: %s: %s", jail ? jail : "",
+    warn("%s%serror executing: %s: %s", jail ? jail : "",
           jail ? ": " : "", cmd);
-  return 0;
+    return 0;
 }
 
 int run_simple_command(const char* jail, const char* cmd, char* env[],
                        char* args[], int opts)
 {
-  pid_t pid;
-  int status = 0;
+    pid_t pid;
+    int status = 0;
 
-  if(opts & JAIL_RUN_NOFORK)
-    return run_overlay_command(jail, cmd, env, args);
+    if(opts & JAIL_RUN_NOFORK)
+        return run_overlay_command(jail, cmd, env, args);
 
-  switch((pid = fork()))
-  {
-  case -1:
-    err(1, "couldn't fork child process");
-    break;
+    switch((pid = fork()))
+    {
+    case -1:
+        err(1, "couldn't fork child process");
+        break;
 
-  /* This is the child here */
-  case 0:
-    if(args)
-      execve(cmd, args, env);
-    else
-      execle(cmd, cmd, NULL, env);
+    /* This is the child here */
+    case 0:
+        if(args)
+            execve(cmd, args, env);
+        else
+            execle(cmd, cmd, NULL, env);
 
-    exit(errno);
-    break;
+        exit(errno);
+        break;
 
-  /* This is the parent process */
-  default:
+    /* This is the parent process */
+    default:
 
-    /* If the processes exited then break out */
-    if(waitpid(pid, &status, 0) == -1)
-      err(1, "couldn't wait on child process");
+        /* If the processes exited then break out */
+        if(waitpid(pid, &status, 0) == -1)
+            err(1, "couldn't wait on child process");
 
-    /* Return any status codes */
-    if(WEXITSTATUS(status) != 0)
-    {
-      warnx("%s%serror executing: %s: %s", jail ? jail : "",
-                jail ? ": " : "", cmd, strerror(WEXITSTATUS(status)));
-      return 0;
-    }
+        /* Return any status codes */
+        if(WEXITSTATUS(status) != 0)
+        {
+            warnx("%s%serror executing: %s: %s", jail ? jail : "",
+                  jail ? ": " : "", cmd, strerror(WEXITSTATUS(status)));
+            return 0;
+        }
 
-    break;
-  }
+        break;
+    }
 
-  return 1;
+    return 1;
 }
 
 /* read & write ends of a pipe */
@@ -342,155 +372,162 @@ int run_simple_command(const char* jail, const char* cmd, char* env[],
 int run_dup_command(const char* jail, const char* cmd, char* env[],
                     char* args[], int opts)
 {
-  int outpipe[2];
-  pid_t pid;
-
-  /*
-   * Special function to duplicate output of a command to two
-   * files.
-   *
-   * NOTE: Yes, I know this may seem like overkill, but system,
-   * popen and all those guys would hang with certain rc scripts.
-   * Those which opened a daemon in the background ('&') but still
-   * kept their output going to the same stdin/stdout handles.
-   */
-
-  /* Create a pipe for the child process */
-  if(pipe(outpipe) < 0)
-    return -1;
-
-  switch(pid = fork())
-  {
-  case -1:
-    err(1, "couldn't fork child process");
-    break;
-
-  /* This is the child here */
-  case 0:
+    int outpipe[2];
+    pid_t pid;
+
+    /*
+     * Special function to duplicate output of a command to two
+     * files.
+     *
+     * NOTE: Yes, I know this may seem like overkill, but system,
+     * popen and all those guys would hang with certain rc scripts.
+     * Those which opened a daemon in the background ('&') but still
+     * kept their output going to the same stdin/stdout handles.
+     */
+
+    /* Create a pipe for the child process */
+    if(pipe(outpipe) < 0)
+        return -1;
+
+    switch(pid = fork())
     {
-      /* Fix up our end of the pipe */
-      if(dup2(outpipe[WRITE_END], STDOUT) < 0 ||
-         dup2(outpipe[WRITE_END], STDERR) < 0)
-        exit(errno);
+    case -1:
+        err(1, "couldn't fork child process");
+        break;
 
-      /* Okay, now run whatever command it was */
-      if(args)
-        execve(cmd, args, env);
-      else
-        execle(cmd, cmd, NULL, env);
-
-      /* In case it returns then have to do this to get
-         children to disconnect from stdout */
-      fflush(stdout);
-      fclose(stdout);
-      close(outpipe[WRITE_END]);
-
-      exit(errno);
-    }
-    break;
-
-
-  /* And this is the parent */
-  default:
-    {
-      int console = -1;
-      int ret;
-      int status = 0;
-      fd_set readmask;
-      char buff[256];
-      struct timeval timeout = { 0, 10000 };
-
-      FD_ZERO(&readmask);
-
-      /* Open the console file and write the header */
-      if(opts & JAIL_RUN_CONSOLE)
-        console = open(_PATH_CONSOLE, O_WRONLY | O_APPEND);
-
-      /* No blocking on the child processes pipe */
-      fcntl(outpipe[READ_END], F_SETFL, fcntl(outpipe[READ_END], F_GETFL, 0) | O_NONBLOCK);
-
-      /* Loop until the process dies or no more output */
-      while(1)
-      {
-        FD_SET(outpipe[READ_END], &readmask);
+    /* This is the child here */
+    case 0:
+        {
+            /* Fix up our end of the pipe */
+            if(dup2(outpipe[WRITE_END], STDOUT) < 0 ||
+               dup2(outpipe[WRITE_END], STDERR) < 0)
+                exit(errno);
+
+            /* Okay, now run whatever command it was */
+            if(args)
+                execve(cmd, args, env);
+            else
+                execle(cmd, cmd, NULL, env);
+
+            /* In case it returns then have to do this to get
+               children to disconnect from stdout */
+            fflush(stdout);
+            fclose(stdout);
+            close(outpipe[WRITE_END]);
+
+            exit(errno);
+        }
+        break;
 
-        if(select(FD_SETSIZE, &readmask, NULL, NULL, &timeout) == -1)
-          err(1, "couldn't select");
 
-        if(FD_ISSET(outpipe[READ_END], &readmask))
+    /* And this is the parent */
+    default:
         {
-          /* Read text */
-          while((ret = read(outpipe[READ_END], buff, 256)) > 0)
-          {
-            if(opts & JAIL_RUN_STDOUT)
-              write(STDOUT, buff, ret);
-
-            if(opts & JAIL_RUN_STDERR)
-              write(STDERR, buff, ret);
+            int console = -1;
+            int ret;
+            int status = 0;
+            int waited = 0;
+            fd_set readmask;
+            char buff[256];
+            struct timeval timeout = { 0, 10000 };
+
+            FD_ZERO(&readmask);
+
+            /* Open the console file and write the header */
+            if(opts & JAIL_RUN_CONSOLE)
+                console = open(_PATH_CONSOLE, O_WRONLY | O_APPEND);
+
+            /* No blocking on the child processes pipe */
+            fcntl(outpipe[READ_END], F_SETFL, fcntl(outpipe[READ_END], F_GETFL, 0) | O_NONBLOCK);
+
+            /* Loop until the process dies or no more output */
+            while(1)
+            {
+                FD_SET(outpipe[READ_END], &readmask);
+
+                if(select(FD_SETSIZE, &readmask, NULL, NULL, &timeout) == -1)
+                    err(1, "couldn't select");
+
+                if(FD_ISSET(outpipe[READ_END], &readmask))
+                {
+                    /* Read text */
+                    while((ret = read(outpipe[READ_END], buff, 256)) > 0)
+                    {
+                        if(opts & JAIL_RUN_STDOUT)
+                            write(STDOUT, buff, ret);
+
+                        if(opts & JAIL_RUN_STDERR)
+                            write(STDERR, buff, ret);
+
+                        if(console != -1)
+                            write(console, buff, ret);
+                    }
+                }
+
+                /* Or if there's an error or end of file */
+                if(ret == -1 && errno != EAGAIN || ret == 0)
+                    break;
+
+                /* If the processes exited then break out */
+                if(waitpid(pid, &status, WNOHANG) == pid)
+                {
+                    waited = 1;
+                    break;
+                }
+            }
+
+            if(!waited)
+                waitpid(pid, &status, 0);
+
+            /* Return any status codes */
+            if(WEXITSTATUS(status) != 0)
+            {
+                warnx("%s%serror executing: %s: %s", jail ? jail : "",
+                    jail ? ": " : "", cmd, strerror(WEXITSTATUS(status)));
+                return 0;
+            }
+
+            /* Clean up */
+            close(outpipe[READ_END]);
 
             if(console != -1)
-              write(console, buff, ret);
-          }
+                close(console);
         }
-
-        /* If the processes exited then break out */
-        if(waitpid(pid, &status, WNOHANG) == pid)
-          break;
-
-        /* Or if there's an error or end of file */
-        if(ret == -1 && errno != EAGAIN || ret == 0)
-          break;
-      }
-
-      /* Return any status codes */
-      if(WEXITSTATUS(status) != 0)
-      {
-        warnx("%s%serror executing: %s: %s", jail ? jail : "",
-                jail ? ": " : "", cmd, strerror(WEXITSTATUS(status)));
-        return 0;
-      }
-
-      /* Clean up */
-      close(outpipe[READ_END]);
-
-      if(console != -1)
-        close(console);
+        break;
     }
-    break;
-  }
 
-  return 1;
+    return 1;
 }
 
 
 int run_jail_command(const char* jail, const char* cmd, char* args[], int opts)
 {
-  char* env[5];
-  char* t;
-  int j;
-
-  memset(env, 0, sizeof(env));
-
-#define MAKE_ENV_VAR(n)                           \
-  t = getenv(n);                                \
-  if(t != NULL)                                  \
-  {                                              \
-    env[j] = alloca(strlen(n) + 2 + strlen(t));  \
-    sprintf(env[j], "%s=%s", (char*)(n), t);    \
-    j++;                                        \
-  }
-
-  /* Prepare an environment for the cmd */
-  env[0] = "PATH=" _PATH_STDPATH;
-  j = 1;
-
-  MAKE_ENV_VAR("TERM");
-  MAKE_ENV_VAR("COLUMNS");
-  MAKE_ENV_VAR("LINES");
-
-  if(opts & JAIL_RUN_OUTPUT)
-    return run_dup_command(jail, cmd, env, args, opts);
-  else
-    return run_simple_command(jail, cmd, env, args, opts);
+    char* env[5];
+    char* t;
+    int j;
+
+    memset(env, 0, sizeof(env));
+
+#define MAKE_ENV_VAR(n)                             \
+    t = getenv(n);                                  \
+    if(t != NULL)                                   \
+    {                                               \
+        env[j] = alloca(strlen(n) + 2 + strlen(t)); \
+        sprintf(env[j], "%s=%s", (char*)(n), t);    \
+        j++;                                        \
+    }
+
+    /* Prepare an environment for the cmd */
+    env[0] = "PATH=" _PATH_STDPATH;
+    j = 1;
+
+    MAKE_ENV_VAR("TERM");
+    MAKE_ENV_VAR("COLUMNS");
+    MAKE_ENV_VAR("LINES");
+
+    if(opts & JAIL_RUN_OUTPUT)
+        return run_dup_command(jail, cmd, env, args, opts);
+    else
+        return run_simple_command(jail, cmd, env, args, opts);
 }
 
diff --git a/srcx/util.h b/srcx/util.h
index fed9261..0696438 100644
--- a/srcx/util.h
+++ b/srcx/util.h
@@ -39,14 +39,16 @@
 #ifndef __UTIL_H__
 #define __UTIL_H__
 
-#include <sys/jail.h>
-#include <kvm.h>
+struct xprison;
 
 int translate_jail_name(const char* str);
 int running_in_jail();
 
-kvm_t* open_kvm_handle(const char* jail, char* errbuf);
-size_t get_jail_sysctl(struct xprison** ret);
+size_t get_jail_sysctl(struct xprison** xp);
+void free_jail_sysctl(size_t len, struct xprison* xp);
+
+int kvm_prepare_jail(struct xprison* xp);
+struct xprison* find_jail(const char* str, size_t len, struct xprison* xp);
 
 #define JAIL_RUN_CONSOLE	0x00000001	/* Output stuff to the jail console if available */
 #define JAIL_RUN_STDOUT		0x00000002	/* Output to stdout */