kit

exec_posix.c (7863B)

---

 /*
  * POSIX implementation of the shared KitExec subprocess interface
  * (<kit/exec.h>). One config-struct spawn serves both the build coordinator
  * (hermetic: exact argv[0], explicit env, mandatory cwd, capture to files) and
  * `kit make` (PATH-searched shell, ambient-style env, optional cwd, capture to
  * a buffer). The user pointer is a DriverEnv* (for its heap).
  */
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #include <kit/exec.h>
 
 #include "env.h"
 
 struct KitExecProc {
   pid_t pid;
   int read_fd; /* stdout capture pipe read end, or -1 */
 };
 
 static char* ex_slice_dup(DriverEnv* env, KitSlice s) {
   char* out = (char*)driver_alloc(env, s.len + 1u);
   if (!out) return NULL;
   if (s.len) memcpy(out, s.s, s.len);
   out[s.len] = '\0';
   return out;
 }
 
 /* Join a relative argv[0] to the current directory (exact/execve path). */
 static char* ex_cwd_join(DriverEnv* env, KitSlice path) {
   char cwd[4096];
   char* out;
   size_t nc, np;
   if (!path.s || path.len == 0u) return NULL;
   if (path.s[0] == '/') return ex_slice_dup(env, path);
   if (!getcwd(cwd, sizeof cwd)) return NULL;
   nc = strlen(cwd);
   np = path.len;
   out = (char*)driver_alloc(env, nc + 1u + np + 1u);
   if (!out) return NULL;
   memcpy(out, cwd, nc);
   out[nc] = '/';
   memcpy(out + nc + 1u, path.s, np);
   out[nc + 1u + np] = '\0';
   return out;
 }
 
 static void ex_free_strv(DriverEnv* env, char** v, size_t n) {
   size_t i;
   if (!v) return;
   for (i = 0; i < n; ++i)
     if (v[i]) driver_free(env, v[i], strlen(v[i]) + 1u);
   driver_free(env, v, (n + 1u) * sizeof *v);
 }
 
 static int ex_reap(pid_t pid, int* exit_code) {
   int st;
   for (;;) {
     if (waitpid(pid, &st, 0) < 0) {
       if (errno == EINTR) continue;
       return 1;
     }
     break;
   }
   if (WIFEXITED(st))
     *exit_code = WEXITSTATUS(st);
   else if (WIFSIGNALED(st))
     *exit_code = -WTERMSIG(st);
   else
     *exit_code = 1;
   return 0;
 }
 
 static int ex_spawn(void* user, const KitExecOpts* opts, KitExecProc** out) {
   DriverEnv* env = (DriverEnv*)user;
   char** av = NULL;
   char** ev = NULL;
   char* cwd_s = NULL;
   char* stdout_s = NULL;
   char* stderr_s = NULL;
   KitExecProc* proc = NULL;
   int pipefd[2] = {-1, -1};
   pid_t pid;
   size_t i;
 
   if (!env || !opts || !opts->argv || opts->argc == 0u || !out) return 1;
   *out = NULL;
 
   av = (char**)driver_alloc(env, (opts->argc + 1u) * sizeof *av);
   ev = (char**)driver_alloc(env, (opts->nenv + 1u) * sizeof *ev);
   if (!av || !ev) goto err;
   memset(av, 0, (opts->argc + 1u) * sizeof *av);
   memset(ev, 0, (opts->nenv + 1u) * sizeof *ev);
   for (i = 0; i < opts->argc; ++i) {
     av[i] = (i == 0u && !opts->search_path) ? ex_cwd_join(env, opts->argv[i])
                                             : ex_slice_dup(env, opts->argv[i]);
     if (!av[i]) goto err;
   }
   for (i = 0; i < opts->nenv; ++i) {
     size_t nk = opts->env[i].key.len, nv = opts->env[i].value.len;
     ev[i] = (char*)driver_alloc(env, nk + 1u + nv + 1u);
     if (!ev[i]) goto err;
     memcpy(ev[i], opts->env[i].key.s, nk);
     ev[i][nk] = '=';
     memcpy(ev[i] + nk + 1u, opts->env[i].value.s, nv);
     ev[i][nk + 1u + nv] = '\0';
   }
   if (opts->cwd.len) {
     cwd_s = ex_slice_dup(env, opts->cwd);
     if (!cwd_s) goto err;
   }
   if (opts->stdout_path.len) {
     stdout_s = ex_slice_dup(env, opts->stdout_path);
     if (!stdout_s) goto err;
   }
   if (opts->stderr_path.len) {
     stderr_s = ex_slice_dup(env, opts->stderr_path);
     if (!stderr_s) goto err;
   }
   proc = (KitExecProc*)driver_alloc_zeroed(env, sizeof *proc);
   if (!proc) goto err;
   proc->read_fd = -1;
 
   if (opts->capture_stdout) {
     if (pipe(pipefd) != 0) goto err;
   } else {
     /* Flush the parent's buffered stdout so a recipe echo precedes the child's
      * own output on the shared fd. */
     fflush(stdout);
   }
 
   pid = fork();
   if (pid < 0) goto err;
   if (pid == 0) {
     extern char** environ;
     if (opts->capture_stdout) {
       close(pipefd[0]);
       if (dup2(pipefd[1], STDOUT_FILENO) < 0) _exit(127);
       close(pipefd[1]);
     } else if (stdout_s) {
       int fd = open(stdout_s, O_WRONLY | O_CREAT | O_TRUNC, 0666);
       if (fd < 0 || dup2(fd, STDOUT_FILENO) < 0) _exit(127);
       close(fd);
     }
     if (stderr_s) {
       int fd = open(stderr_s, O_WRONLY | O_CREAT | O_TRUNC, 0666);
       if (fd < 0 || dup2(fd, STDERR_FILENO) < 0) _exit(127);
       close(fd);
     }
     if (cwd_s && chdir(cwd_s) != 0) _exit(127);
     if (opts->search_path) {
       environ = ev; /* execvp draws PATH and the child env from here */
       execvp(av[0], av);
     } else {
       execve(av[0], av, ev);
     }
     _exit(127);
   }
   proc->pid = pid;
   if (opts->capture_stdout) {
     close(pipefd[1]);
     proc->read_fd = pipefd[0];
   }
   *out = proc;
   ex_free_strv(env, av, opts->argc);
   ex_free_strv(env, ev, opts->nenv);
   if (cwd_s) driver_free(env, cwd_s, strlen(cwd_s) + 1u);
   if (stdout_s) driver_free(env, stdout_s, strlen(stdout_s) + 1u);
   if (stderr_s) driver_free(env, stderr_s, strlen(stderr_s) + 1u);
   return 0;
 
 err:
   if (pipefd[0] >= 0) close(pipefd[0]);
   if (pipefd[1] >= 0) close(pipefd[1]);
   ex_free_strv(env, av, opts ? opts->argc : 0u);
   ex_free_strv(env, ev, opts ? opts->nenv : 0u);
   if (cwd_s) driver_free(env, cwd_s, strlen(cwd_s) + 1u);
   if (stdout_s) driver_free(env, stdout_s, strlen(stdout_s) + 1u);
   if (stderr_s) driver_free(env, stderr_s, strlen(stderr_s) + 1u);
   if (proc) driver_free(env, proc, sizeof *proc);
   return 1;
 }
 
 static int ex_wait(void* user, KitExecProc* proc, int* exit_code, uint8_t** out,
                    size_t* out_len) {
   DriverEnv* env = (DriverEnv*)user;
   uint8_t* buf = NULL;
   size_t len = 0;
   size_t cap = 0;
   int oom = 0;
   int rc;
 
   if (!env || !proc || !exit_code) return 1;
   if (out) *out = NULL;
   if (out_len) *out_len = 0;
 
   if (proc->read_fd >= 0) {
     for (;;) {
       uint8_t tmp[4096];
       ssize_t n = read(proc->read_fd, tmp, sizeof tmp);
       if (n < 0) {
         if (errno == EINTR) continue;
         break;
       }
       if (n == 0) break;
       /* Keep draining after an allocation failure so the child never blocks. */
       if (!oom && len + (size_t)n > cap) {
         size_t ncap = cap ? cap : 8192;
         uint8_t* nb;
         while (ncap < len + (size_t)n) ncap *= 2;
         nb = env->heap->realloc(env->heap, buf, cap, ncap, 8);
         if (!nb) {
           env->heap->free(env->heap, buf, cap);
           buf = NULL;
           cap = 0;
           len = 0;
           oom = 1;
         } else {
           buf = nb;
           cap = ncap;
         }
       }
       if (!oom) {
         memcpy(buf + len, tmp, (size_t)n);
         len += (size_t)n;
       }
     }
     close(proc->read_fd);
   }
 
   rc = ex_reap(proc->pid, exit_code);
   driver_free(env, proc, sizeof *proc);
   if (out) {
     *out = buf;
     if (out_len) *out_len = len;
   } else if (buf) {
     env->heap->free(env->heap, buf, cap);
   }
   return rc;
 }
 
 static int ex_poll(void* user, KitExecProc* proc, int* done, int* exit_code) {
   DriverEnv* env = (DriverEnv*)user;
   int st;
   pid_t r;
   if (!env || !proc || !done || !exit_code) return 1;
   *done = 0;
   do {
     r = waitpid(proc->pid, &st, WNOHANG);
   } while (r < 0 && errno == EINTR);
   if (r < 0) return 1;
   if (r == 0) return 0;
   *done = 1;
   if (WIFEXITED(st))
     *exit_code = WEXITSTATUS(st);
   else if (WIFSIGNALED(st))
     *exit_code = -WTERMSIG(st);
   else
     *exit_code = 1;
   if (proc->read_fd >= 0) close(proc->read_fd);
   driver_free(env, proc, sizeof *proc);
   return 0;
 }
 
 static void ex_kill(void* user, KitExecProc* proc) {
   (void)user;
   if (proc) kill(proc->pid, SIGTERM);
 }
 
 KitExec driver_exec(DriverEnv* env) {
   KitExec ex;
   ex.spawn = ex_spawn;
   ex.wait = ex_wait;
   ex.poll = ex_poll;
   ex.kill = ex_kill;
   ex.user = env;
   return ex;
 }