native_process_capture.c

Go to the documentation of this file.

/**
 * @file
 * @brief Runs child processes and captures their output, optionally with injected environment values.
 */
 
#include "native_process_capture.h"
 
#include "native_support.h"
 
#ifndef _WIN32
#ifndef __wasm__
 
#include <poll.h>
#include <spawn.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>
 
extern char **environ;
 
static int append_pipe_to_buffer(int fd, Buffer *buffer, int *open_flag) {
  char chunk[4096];
  ssize_t bytes_read = read(fd, chunk, sizeof(chunk));
  if (bytes_read > 0) {
    if (buffer_append(buffer, chunk, (size_t)bytes_read) != 0) {
      return -1;
    }
    return 0;
  }
  if (bytes_read == 0) {
    close(fd);
    *open_flag = 0;
    return 0;
  }
  return -1;
}
 
static char *build_child_env_assignment_native(const char *key, const char *value) {
  size_t key_len;
  size_t value_len;
  char *assignment;
  if (key == NULL || key[0] == '\0' || value == NULL || value[0] == '\0') {
    return NULL;
  }
  key_len = strlen(key);
  value_len = strlen(value);
  assignment = (char *)malloc(key_len + value_len + 2);
  if (assignment == NULL) {
    return NULL;
  }
  memcpy(assignment, key, key_len);
  assignment[key_len] = '=';
  memcpy(assignment + key_len + 1, value, value_len + 1);
  return assignment;
}
 
static void free_child_env_native(char **child_env, size_t base_count, size_t child_count) {
  size_t index;
  if (child_env == NULL) {
    return;
  }
  for (index = base_count; index < child_count; index++) {
    free(child_env[index]);
  }
  free(child_env);
}
 
static char **build_child_env_native(const char *env_keys[], const char *env_values[], size_t env_count, size_t *base_count_out, size_t *child_count_out) {
  size_t base_count = 0;
  size_t child_count = 0;
  char **child_env = NULL;
  size_t env_index;
  if (base_count_out != NULL) {
    *base_count_out = 0;
  }
  if (child_count_out != NULL) {
    *child_count_out = 0;
  }
  while (environ != NULL && environ[base_count] != NULL) {
    base_count++;
  }
  child_env = (char **)malloc(sizeof(char *) * (base_count + env_count + 1));
  if (child_env == NULL) {
    return NULL;
  }
  for (size_t base_index = 0; base_index < base_count; base_index++) {
    const char *entry = environ[base_index];
    int overridden = 0;
    for (env_index = 0; env_index < env_count; env_index++) {
      const char *key = env_keys != NULL ? env_keys[env_index] : NULL;
      size_t key_len = key != NULL ? strlen(key) : 0;
      if (key_len > 0 && strncmp(entry, key, key_len) == 0 && entry[key_len] == '=') {
        overridden = 1;
        break;
      }
    }
    if (!overridden) {
      child_env[child_count++] = environ[base_index];
    }
  }
  for (env_index = 0; env_index < env_count; env_index++) {
    char *assignment = build_child_env_assignment_native(
      env_keys != NULL ? env_keys[env_index] : NULL,
      env_values != NULL ? env_values[env_index] : NULL
    );
    if (assignment != NULL) {
      child_env[child_count++] = assignment;
    }
  }
  child_env[child_count] = NULL;
  if (base_count_out != NULL) {
    *base_count_out = base_count;
  }
  if (child_count_out != NULL) {
    *child_count_out = child_count;
  }
  return child_env;
}
 
int capture_execv_output_split_env_native(char *const argv[], const char *env_keys[], const char *env_values[], size_t env_count, char **stdout_output, size_t *stdout_len, char **stderr_output, size_t *stderr_len) {
  int stdout_pipefd[2];
  int stderr_pipefd[2];
  pid_t pid;
  Buffer stdout_buffer;
  Buffer stderr_buffer;
  int status_code = 0;
  int stdout_open = 1;
  int stderr_open = 1;
  posix_spawn_file_actions_t file_actions;
  char **child_env = NULL;
  size_t base_count = 0;
  size_t child_count = 0;
  int spawn_errno = 0;
  int file_actions_ready = 0;
  buffer_init(&stdout_buffer);
  buffer_init(&stderr_buffer);
  if (stdout_output != NULL) {
    *stdout_output = NULL;
  }
  if (stdout_len != NULL) {
    *stdout_len = 0;
  }
  if (stderr_output != NULL) {
    *stderr_output = NULL;
  }
  if (stderr_len != NULL) {
    *stderr_len = 0;
  }
  if (argv == NULL || argv[0] == NULL) {
    return 69;
  }
  if (pipe(stdout_pipefd) != 0) {
    return 69;
  }
  if (pipe(stderr_pipefd) != 0) {
    close(stdout_pipefd[0]);
    close(stdout_pipefd[1]);
    return 69;
  }
  child_env = build_child_env_native(env_keys, env_values, env_count, &base_count, &child_count);
  if (env_count > 0 && child_env == NULL) {
    close(stdout_pipefd[0]);
    close(stdout_pipefd[1]);
    close(stderr_pipefd[0]);
    close(stderr_pipefd[1]);
    return 69;
  }
  if (posix_spawn_file_actions_init(&file_actions) != 0) {
    free_child_env_native(child_env, base_count, child_count);
    close(stdout_pipefd[0]);
    close(stdout_pipefd[1]);
    close(stderr_pipefd[0]);
    close(stderr_pipefd[1]);
    return 69;
  }
  file_actions_ready = 1;
  if (posix_spawn_file_actions_adddup2(&file_actions, stdout_pipefd[1], STDOUT_FILENO) != 0 ||
      posix_spawn_file_actions_adddup2(&file_actions, stderr_pipefd[1], STDERR_FILENO) != 0 ||
      posix_spawn_file_actions_addclose(&file_actions, stdout_pipefd[0]) != 0 ||
      posix_spawn_file_actions_addclose(&file_actions, stdout_pipefd[1]) != 0 ||
      posix_spawn_file_actions_addclose(&file_actions, stderr_pipefd[0]) != 0 ||
      posix_spawn_file_actions_addclose(&file_actions, stderr_pipefd[1]) != 0) {
    posix_spawn_file_actions_destroy(&file_actions);
    free_child_env_native(child_env, base_count, child_count);
    close(stdout_pipefd[0]);
    close(stdout_pipefd[1]);
    close(stderr_pipefd[0]);
    close(stderr_pipefd[1]);
    return 69;
  }
  spawn_errno = posix_spawn(&pid, argv[0], &file_actions, NULL, argv, child_env != NULL ? child_env : environ);
  if (file_actions_ready) {
    posix_spawn_file_actions_destroy(&file_actions);
  }
  free_child_env_native(child_env, base_count, child_count);
  if (spawn_errno != 0) {
    close(stdout_pipefd[0]);
    close(stdout_pipefd[1]);
    close(stderr_pipefd[0]);
    close(stderr_pipefd[1]);
    return 69;
  }
  close(stdout_pipefd[1]);
  close(stderr_pipefd[1]);
  while (stdout_open || stderr_open) {
    struct pollfd fds[2];
    nfds_t nfds = 0;
    if (stdout_open) {
      fds[nfds].fd = stdout_pipefd[0];
      fds[nfds].events = POLLIN | POLLHUP;
      nfds++;
    }
    if (stderr_open) {
      fds[nfds].fd = stderr_pipefd[0];
      fds[nfds].events = POLLIN | POLLHUP;
      nfds++;
    }
    if (poll(fds, nfds, -1) < 0) {
      if (stdout_open) close(stdout_pipefd[0]);
      if (stderr_open) close(stderr_pipefd[0]);
      waitpid(pid, NULL, 0);
      buffer_free(&stdout_buffer);
      buffer_free(&stderr_buffer);
      return 69;
    }
    nfds = 0;
    if (stdout_open) {
      if (fds[nfds].revents & (POLLIN | POLLHUP)) {
        if (append_pipe_to_buffer(stdout_pipefd[0], &stdout_buffer, &stdout_open) != 0) {
          if (stdout_open) close(stdout_pipefd[0]);
          if (stderr_open) close(stderr_pipefd[0]);
          waitpid(pid, NULL, 0);
          buffer_free(&stdout_buffer);
          buffer_free(&stderr_buffer);
          return 69;
        }
      }
      nfds++;
    }
    if (stderr_open) {
      if (fds[nfds].revents & (POLLIN | POLLHUP)) {
        if (append_pipe_to_buffer(stderr_pipefd[0], &stderr_buffer, &stderr_open) != 0) {
          if (stdout_open) close(stdout_pipefd[0]);
          if (stderr_open) close(stderr_pipefd[0]);
          waitpid(pid, NULL, 0);
          buffer_free(&stdout_buffer);
          buffer_free(&stderr_buffer);
          return 69;
        }
      }
    }
  }
  waitpid(pid, &status_code, 0);
  if (stdout_output != NULL) {
    *stdout_output = stdout_buffer.data;
  } else {
    buffer_free(&stdout_buffer);
  }
  if (stdout_len != NULL) {
    *stdout_len = stdout_buffer.len;
  }
  if (stderr_output != NULL) {
    *stderr_output = stderr_buffer.data;
  } else {
    buffer_free(&stderr_buffer);
  }
  if (stderr_len != NULL) {
    *stderr_len = stderr_buffer.len;
  }
  if (WIFEXITED(status_code)) {
    return WEXITSTATUS(status_code);
  }
  return 69;
}
 
int capture_execv_output_env_native(char *const argv[], const char *env_keys[], const char *env_values[], size_t env_count, char **output, size_t *output_len) {
  char *stdout_output = NULL;
  char *stderr_output = NULL;
  size_t stdout_captured_len = 0;
  size_t stderr_captured_len = 0;
  int code = capture_execv_output_split_env_native(argv, env_keys, env_values, env_count, &stdout_output, &stdout_captured_len, &stderr_output, &stderr_captured_len);
  Buffer combined;
  buffer_init(&combined);
  if (stdout_output != NULL && stdout_captured_len > 0) {
    if (buffer_append(&combined, stdout_output, stdout_captured_len) != 0) {
      free(stdout_output);
      free(stderr_output);
      return 69;
    }
  }
  if (stderr_output != NULL && stderr_captured_len > 0) {
    if (buffer_append(&combined, stderr_output, stderr_captured_len) != 0) {
      free(stdout_output);
      free(stderr_output);
      buffer_free(&combined);
      return 69;
    }
  }
  free(stdout_output);
  free(stderr_output);
  if (output != NULL) {
    *output = combined.data;
  } else {
    buffer_free(&combined);
  }
  if (output_len != NULL) {
    *output_len = combined.len;
  }
  return code;
}
 
int capture_execv_output_native(char *const argv[], char **output, size_t *output_len) {
  return capture_execv_output_env_native(argv, NULL, NULL, 0, output, output_len);
}
 
int run_process_capture_native(char *const argv[], char **output) {
  return capture_execv_output_native(argv, output, NULL);
}
 
#else
int capture_execv_output_native(char *const argv[], char **output, size_t *output_len) {
  (void)argv;
  (void)output;
  (void)output_len;
  return 78;
}
 
int capture_execv_output_split_env_native(char *const argv[], const char *env_keys[], const char *env_values[], size_t env_count, char **stdout_output, size_t *stdout_len, char **stderr_output, size_t *stderr_len) {
  (void)argv;
  (void)env_keys;
  (void)env_values;
  (void)env_count;
  (void)stdout_output;
  (void)stdout_len;
  (void)stderr_output;
  (void)stderr_len;
  return 78;
}
 
int run_process_capture_native(char *const argv[], char **output) {
  (void)argv;
  (void)output;
  return 78;
}
#endif
#else
int capture_execv_output_native(char *const argv[], char **output, size_t *output_len) {
  (void)argv;
  (void)output;
  (void)output_len;
  return 78;
}
 
int capture_execv_output_split_env_native(char *const argv[], const char *env_keys[], const char *env_values[], size_t env_count, char **stdout_output, size_t *stdout_len, char **stderr_output, size_t *stderr_len) {
  (void)argv;
  (void)env_keys;
  (void)env_values;
  (void)env_count;
  (void)stdout_output;
  (void)stdout_len;
  (void)stderr_output;
  (void)stderr_len;
  return 78;
}
 
int run_process_capture_native(char *const argv[], char **output) {
  (void)argv;
  (void)output;
  return 78;
}
#endif