exec.c

#include "shell/exec/exec.h"
#include "shell/builtins/builtins.h"
#include "shell/path/path.h"
#include "shell/redir/redir.h"

#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>

static void close_pipes(int (*pipes)[2], int n) {
  for (int i = 0; i < n; ++i) {
    close(pipes[i][0]);
    close(pipes[i][1]);
  }
}

int shell_execute_pipeline(const ShellPipeline *p, ShellContext *ctx) {
  (void)ctx;
  if (!p || p->count <= 0)
    return -1;

  if (p->count == 1) {
    const ShellCommand *c = &p->cmds[0];
    if (!c->argv || !c->argv[0])
      return 0;

    BuiltinKind bk = builtins_classify(c->argv[0]);
    if (bk != BUILTIN_NONE && !builtin_requires_parent(bk)) {
      pid_t pid = fork();
      if (pid < 0) {
        perror("fork");
        return -1;
      }
      if (pid == 0) {
        if (shell_redir_apply(&c->redir, NULL, NULL) != 0)
          _exit(1);
        builtin_run(bk, c, ctx, 1, NULL);
        _exit(0);
      }
      int status = 0;
      waitpid(pid, &status, 0);
      return 0;
    }

    char resolved[4096];
    if (!path_resolve_executable(c->argv[0], resolved, sizeof(resolved))) {
      printf("%s: command not found\n", c->argv[0]);
      return 0;
    }

    pid_t pid = fork();
    if (pid < 0) {
      perror("fork");
      return -1;
    }
    if (pid == 0) {
      if (shell_redir_apply(&c->redir, NULL, NULL) != 0)
        _exit(1);
      execv(resolved, c->argv);
      fprintf(stderr, "%s: failed to execute\n", c->argv[0]);
      _exit(127);
    }

    int status = 0;
    waitpid(pid, &status, 0);
    return 0;
  }

  int stages = p->count;
  int pipes_count = stages - 1;
  int(*pipes)[2] = malloc(sizeof(int[2]) * (size_t)pipes_count);
  if (!pipes) {
    perror("malloc");
    return -1;
  }

  for (int i = 0; i < pipes_count; ++i) {
    if (pipe(pipes[i]) != 0) {
      perror("pipe");
      for (int j = 0; j < i; ++j) {
        close(pipes[j][0]);
        close(pipes[j][1]);
      }
      free(pipes);
      return -1;
    }
  }

  pid_t *pids = calloc((size_t)stages, sizeof(pid_t));
  if (!pids) {
    perror("calloc");
    close_pipes(pipes, pipes_count);
    free(pipes);
    return -1;
  }

  int started = 0;
  for (int si = 0; si < stages; ++si) {
    pid_t pid = fork();
    if (pid < 0) {
      perror("fork");
      /* kill already started */
      for (int k = 0; k < started; ++k)
        kill(pids[k], SIGKILL);
      break;
    }

    if (pid == 0) {
      /* stdin from previous pipe */
      if (si > 0) {
        if (dup2(pipes[si - 1][0], STDIN_FILENO) < 0) {
          perror("dup2");
          _exit(1);
        }
      }
      /* stdout to next pipe */
      if (si < stages - 1) {
        if (dup2(pipes[si][1], STDOUT_FILENO) < 0) {
          perror("dup2");
          _exit(1);
        }
      }

      close_pipes(pipes, pipes_count);

      const ShellCommand *c = &p->cmds[si];
      if (!c->argv || !c->argv[0])
        _exit(0);

      if (shell_redir_apply(&c->redir, NULL, NULL) != 0)
        _exit(1);

      BuiltinKind bk = builtins_classify(c->argv[0]);
      if (bk != BUILTIN_NONE) {
        builtin_run(bk, c, ctx, 1, NULL);
        _exit(0);
      }

      char resolved[4096];
      if (!path_resolve_executable(c->argv[0], resolved, sizeof(resolved))) {
        fprintf(stderr, "%s: command not found\n", c->argv[0]);
        _exit(127);
      }

      execv(resolved, c->argv);
      fprintf(stderr, "%s: failed to execute\n", c->argv[0]);
      _exit(127);
    }

    pids[si] = pid;
    started++;
  }

  close_pipes(pipes, pipes_count);
  free(pipes);

  for (int i = 0; i < started; ++i) {
    int status = 0;
    waitpid(pids[i], &status, 0);
  }

  free(pids);
  return 0;
}