bashc.h

#ifndef BASHC_H
#define BASHC_H

#ifndef BASHC_BIN_COUNT
#error "BASHC_BIN_COUNT must be defined before including bashc.h"
#endif

#ifndef BASHC_LIB_COUNT
#error "BASHC_LIB_COUNT must be defined before including bashc.h"
#endif

#define _GNU_SOURCE

#include <errno.h>
#include <fcntl.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <unistd.h>

extern char **environ;

/* --- Data Structures --- */

struct bin {
  const unsigned char *data;
  size_t size;
  int fd;
  bool loaded;
  size_t *libs;
  size_t lib_count;
  bool interpreted;
  size_t interpreter;
};

struct lib {
  const unsigned char *data;
  size_t size;
  int fd;
  bool loaded;
};

/* --- Global Storage --- */
/* Marked extern to allow inclusion in multiple files */
extern struct bin bins[BASHC_BIN_COUNT];
extern struct lib libs[BASHC_LIB_COUNT];

/* --- Macros --- */

/* * Helper to construct the library list.
 */
#define BINLIBS(...)                                                           \
  ({                                                                           \
    size_t stacklibs[] = {__VA_ARGS__};                                        \
    size_t count = sizeof(stacklibs) / sizeof(size_t);                         \
    size_t *heaplibs = calloc(count, sizeof(size_t));                          \
    if (heaplibs) {                                                            \
      for (size_t i = 0; i < count; ++i)                                       \
        heaplibs[i] = stacklibs[i];                                            \
    }                                                                          \
    heaplibs;                                                                  \
  })

/* --- Function Prototypes --- */

/**
 * Executes a binary defined in the bins array.
 * @param bin_index Index of the binary in the bins array.
 * @param argvin Null-terminated array of argument strings.
 * @param envin Null-terminated array of environment strings.
 * @param pstdout stdout for program
 * @param pstdin stdin for program
 * @param pstderr stderr for program
 * @return Exit status of the command, or -1 on setup failure.
 */
int run_command(size_t bin_index, char *const argvin[], char *const envin[],
                int fin, int fout, int ferr);

/* --- Implementation Section --- */
#ifdef BASHC_IMPLEMENTATION

struct bin bins[BASHC_BIN_COUNT] = {0};
struct lib libs[BASHC_LIB_COUNT] = {0};

static char ARGV0_ARG[] = "--argv0";
static char INHIBIT_CACHE_ARG[] = "--inhibit-cache";

/* Helper: Load data into a memfd */
static int load_memfd_resource(const unsigned char *data, size_t size,
                               int *out_fd, bool *loaded) {
  if (*loaded && *out_fd > 0) {
    return *out_fd;
  }

  int fd = memfd_create("bashc_memfd", 0);
  if (fd < 0) {
    perror("bashc: memfd_create failed");
    return -1;
  }

  if (write(fd, data, size) != (ssize_t)size) {
    perror("bashc: write failed");
    close(fd);
    return -1;
  }

  *out_fd = fd;
  *loaded = true;
  return fd;
}

int lib_get(size_t index) {
  if (index >= BASHC_LIB_COUNT)
    return -1;
  return load_memfd_resource(libs[index].data, libs[index].size,
                             &libs[index].fd, &libs[index].loaded);
}

int bin_get(size_t index) {
  if (index >= BASHC_BIN_COUNT)
    return -1;
  return load_memfd_resource(bins[index].data, bins[index].size,
                             &bins[index].fd, &bins[index].loaded);
}

static size_t ptr_array_len(char *const arr[]) {
  size_t count = 0;
  if (!arr)
    return 0;
  while (arr[count] != NULL)
    count++;
  return count;
}

static char *get_fd_path(int fd) {
  char buf[64];
  snprintf(buf, sizeof(buf), "/proc/self/fd/%d", fd);
  return strdup(buf);
}

int run_command(size_t b, char *const argvin[], char *const envin[], int fin,
                int fout, int ferr) {
  if (b >= BASHC_BIN_COUNT) {
    fprintf(stderr, "bashc: Invalid bin index %zu\n", b);
    return -1;
  }

  struct bin *curr_bin = &bins[b];

  // Load the binary
  int binfd = bin_get(b);
  if (binfd < 0)
    return -1;

  // Prepare Environment (LD_PRELOAD injection)
  size_t envin_size = ptr_array_len(envin);
  // Allocate space for existing env + LD_PRELOADs + NULL terminator
  char **env = calloc(curr_bin->lib_count + envin_size + 1, sizeof(char *));
  if (!env)
    return -1;

  // Copy existing environment
  for (size_t i = 0; i < envin_size; i++) {
    env[i] = envin[i];
  }

  // Inject libraries
  if (curr_bin->lib_count > 0) {
    // Calculate buffer size:
    // "LD_PRELOAD=" (11 chars) + (~20 chars per path) + (colons) + (null
    // terminator) We allocate 64 bytes per lib to be extremely safe and avoid
    // truncation.
    size_t buf_size = 12 + (curr_bin->lib_count * 64);
    char *preload_str = calloc(buf_size, sizeof(char));

    if (!preload_str) {
      free(env);
      return -1;
    }

    // Start the string
    strcpy(preload_str, "LD_PRELOAD=");

    for (size_t i = 0; i < curr_bin->lib_count; i++) {
      int libfd = lib_get(curr_bin->libs[i]);
      if (libfd < 0) {
        free(preload_str);
        free(env);
        return -1;
      }

      // Format the path into a temporary buffer
      char path[64];
      snprintf(path, sizeof(path), "/proc/self/fd/%d", libfd);

      // Append path to the main string
      strcat(preload_str, path);

      // Append a colon separator if this is not the last library
      if (i < curr_bin->lib_count - 1) {
        strcat(preload_str, ":");
      }
    }

    env[envin_size] = preload_str;
  }

  // Prepare Arguments
  size_t argvin_size = ptr_array_len(argvin);
  size_t offset = curr_bin->interpreted ? 4 : 0;
  char **argv = calloc(argvin_size + offset + 1, sizeof(char *));

  if (!argv) {
    // Cleanup env
    for (size_t i = 0; i < curr_bin->lib_count; i++)
      free(env[envin_size + i]);
    free(env);
    return -1;
  }

  int execfd = binfd;
  char *bin_path = get_fd_path(binfd);
  char *interp_path = NULL;

  if (curr_bin->interpreted) {
    int interpfd = lib_get(curr_bin->interpreter);
    if (interpfd < 0) {
      // Cleanup
      free(bin_path);
      for (size_t i = 0; i < curr_bin->lib_count; i++)
        free(env[envin_size + i]);
      free(env);
      free(argv);
      return -1;
    }

    execfd = interpfd;
    interp_path = get_fd_path(interpfd);

    argv[0] = interp_path;
    argv[1] = INHIBIT_CACHE_ARG;
    argv[2] = ARGV0_ARG;
    argv[3] = argvin[0]; // The original program name
    argv[4] = bin_path;  // The actual binary path
    for (size_t i = 1; i < argvin_size; i++) {
      argv[i + 4] = argvin[i];
    }
  } else {
    for (size_t i = 0; i < argvin_size; i++) {
      argv[i] = argvin[i];
    }
  }

  // Fork and Exec
  pid_t pid = fork();
  if (pid < 0) {
    perror("bashc: fork failed");
    // Cleanup everything
    free(bin_path);
    if (interp_path)
      free(interp_path);
    for (size_t i = 0; i < curr_bin->lib_count; i++)
      free(env[envin_size + i]);
    free(env);
    free(argv);
    return -1;
  }

  if (pid == 0) {
    if (fin != STDIN_FILENO) {
      if (dup2(fin, STDIN_FILENO) == -1) {
        perror("dup2 stdin");
        exit(1);
      }
      close(fin);
    }

    if (fout != STDOUT_FILENO) {
      if (dup2(fout, STDOUT_FILENO) == -1) {
        perror("dup2 stdout");
        exit(1);
      }
      close(fout);
    }

    if (ferr != STDERR_FILENO) {
      if (dup2(ferr, STDERR_FILENO) == -1) {
        perror("dup2 stderr");
        exit(1);
      }
      close(ferr);
    }
    fexecve(execfd, argv, env);
    perror("bashc: fexecve failed");
    exit(127);
  }

  int status;
  waitpid(pid, &status, 0);

  // Cleanup Heap Memory
  free(bin_path);
  if (interp_path)
    free(interp_path);

  // Free the LD_PRELOAD strings
  for (size_t i = 0; i < curr_bin->lib_count; i++) {
    free(env[envin_size + i]);
  }

  free(env);
  free(argv);

  return status;
}

#endif // BASHC_IMPLEMENTATION
#endif // BASHC_H