Move core libraries into their own folder

1 files changed, 285 insertions, 0 deletions

diff --git a/lib/commands/commands.c b/lib/commands/commands.c
new file mode 100644
index 00000000..973fc0c5
--- /dev/null
+++ b/lib/commands/commands.c
@@ -0,0 +1,285 @@
+#pragma once
+
+#include <errno.h>
+#include <gc.h>
+#include <poll.h>
+#include <pthread.h>
+#include <signal.h>
+#include <spawn.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <sys/param.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <unistr.h>
+
+#define READ_END 0
+#define WRITE_END 1
+int run_command(Text_t exe, List_t arg_list, Table_t env_table,
+                       OptionalList_t input_bytes, List_t *output_bytes, List_t *error_bytes)
+{
+    pthread_testcancel();
+
+    struct sigaction sa = { .sa_handler = SIG_IGN }, oldint, oldquit;
+    sigaction(SIGINT, &sa, &oldint);
+    sigaction(SIGQUIT, &sa, &oldquit);
+    sigaddset(&sa.sa_mask, SIGCHLD);
+    sigset_t old, reset;
+    sigprocmask(SIG_BLOCK, &sa.sa_mask, &old);
+    sigemptyset(&reset);
+    if (oldint.sa_handler != SIG_IGN) sigaddset(&reset, SIGINT);
+    if (oldquit.sa_handler != SIG_IGN) sigaddset(&reset, SIGQUIT);
+    posix_spawnattr_t attr;
+    posix_spawnattr_init(&attr);
+    posix_spawnattr_setsigmask(&attr, &old);
+    posix_spawnattr_setsigdefault(&attr, &reset);
+    posix_spawnattr_setflags(&attr, POSIX_SPAWN_SETSIGDEF|POSIX_SPAWN_SETSIGMASK);
+
+    int child_inpipe[2], child_outpipe[2], child_errpipe[2];
+    if (input_bytes.length >= 0) pipe(child_inpipe);
+    if (output_bytes) pipe(child_outpipe);
+    if (error_bytes) pipe(child_errpipe);
+
+    posix_spawn_file_actions_t actions;
+    posix_spawn_file_actions_init(&actions);
+    if (input_bytes.length >= 0) {
+        posix_spawn_file_actions_adddup2(&actions, child_inpipe[READ_END], STDIN_FILENO);
+        posix_spawn_file_actions_addclose(&actions, child_inpipe[WRITE_END]);
+    }
+    if (output_bytes) {
+        posix_spawn_file_actions_adddup2(&actions, child_outpipe[WRITE_END], STDOUT_FILENO);
+        posix_spawn_file_actions_addclose(&actions, child_outpipe[READ_END]);
+    }
+    if (error_bytes) {
+        posix_spawn_file_actions_adddup2(&actions, child_errpipe[WRITE_END], STDERR_FILENO);
+        posix_spawn_file_actions_addclose(&actions, child_errpipe[READ_END]);
+    }
+
+    const char *exe_str = Text$as_c_string(exe);
+
+    List_t arg_strs = {};
+    List$insert_value(&arg_strs, exe_str, I(0), sizeof(char*));
+    for (int64_t i = 0; i < arg_list.length; i++)
+        List$insert_value(&arg_strs, Text$as_c_string(*(Text_t*)(arg_list.data + i*arg_list.stride)), I(0), sizeof(char*));
+    List$insert_value(&arg_strs, NULL, I(0), sizeof(char*));
+    char **args = arg_strs.data;
+
+    extern char **environ;
+    char **env = environ;
+    if (env_table.entries.length > 0) {
+        List_t env_list = {}; // List of const char*
+        for (char **e = environ; *e; e++)
+            List$insert(&env_list, e, I(0), sizeof(char*));
+
+        for (int64_t i = 0; i < env_table.entries.length; i++) {
+            struct { Text_t key, value; } *entry = env_table.entries.data + env_table.entries.stride*i;
+            const char *env_entry = String(entry->key, "=", entry->value);
+            List$insert(&env_list, &env_entry, I(0), sizeof(char*));
+        }
+        List$insert_value(&env_list, NULL, I(0), sizeof(char*));
+        assert(env_list.stride == sizeof(char*));
+        env = env_list.data;
+    }
+
+    pid_t pid;
+    int ret = exe_str[0] == '/' ?
+        posix_spawn(&pid, exe_str, &actions, &attr, args, env)
+        : posix_spawnp(&pid, exe_str, &actions, &attr, args, env);
+    if (ret != 0)
+        return -1;
+
+    posix_spawnattr_destroy(&attr);
+    posix_spawn_file_actions_destroy(&actions);
+
+    if (input_bytes.length >= 0) close(child_inpipe[READ_END]);
+    if (output_bytes) close(child_outpipe[WRITE_END]);
+    if (error_bytes) close(child_errpipe[WRITE_END]);
+
+    struct pollfd pollfds[3] = {};
+    if (input_bytes.length >= 0) pollfds[0] = (struct pollfd){.fd=child_inpipe[WRITE_END], .events=POLLOUT};
+    if (output_bytes) pollfds[1] = (struct pollfd){.fd=child_outpipe[WRITE_END], .events=POLLIN};
+    if (error_bytes) pollfds[2] = (struct pollfd){.fd=child_errpipe[WRITE_END], .events=POLLIN};
+
+    if (input_bytes.length > 0 && input_bytes.stride != 1)
+        List$compact(&input_bytes, sizeof(char));
+    if (output_bytes)
+        *output_bytes = (List_t){.atomic=1, .stride=1, .length=0};
+    if (error_bytes)
+        *error_bytes = (List_t){.atomic=1, .stride=1, .length=0};
+
+    while (input_bytes.length > 0 || output_bytes || error_bytes) {
+        (void)poll(pollfds, sizeof(pollfds)/sizeof(pollfds[0]), -1);  // Wait for data or readiness
+        bool did_something = false;
+        if (input_bytes.length >= 0 && pollfds[0].revents) {
+            if (input_bytes.length > 0) {
+                ssize_t written = write(child_inpipe[WRITE_END], input_bytes.data, (size_t)input_bytes.length);
+                if (written > 0) {
+                    input_bytes.data += written;
+                    input_bytes.length -= (int64_t)written;
+                    did_something = true;
+                } else if (written < 0) {
+                    close(child_inpipe[WRITE_END]);
+                    pollfds[0].events = 0;
+                }
+            }
+            if (input_bytes.length <= 0) {
+                close(child_inpipe[WRITE_END]);
+                pollfds[0].events = 0;
+            }
+        }
+        char buf[256];
+        if (output_bytes && pollfds[1].revents) {
+            ssize_t n = read(child_outpipe[READ_END], buf, sizeof(buf));
+            did_something = did_something || (n > 0);
+            if (n <= 0) {
+                close(child_outpipe[READ_END]);
+                pollfds[1].events = 0;
+            } else if (n > 0) {
+                if (output_bytes->free < n) {
+                    output_bytes->data = GC_REALLOC(output_bytes->data, (size_t)(output_bytes->length + n));
+                    output_bytes->free = 0;
+                }
+                memcpy(output_bytes->data + output_bytes->length, buf, (size_t)n);
+                output_bytes->length += n;
+            }
+        }
+        if (error_bytes && pollfds[2].revents) {
+            ssize_t n = read(child_errpipe[READ_END], buf, sizeof(buf));
+            did_something = did_something || (n > 0);
+            if (n <= 0) {
+                close(child_errpipe[READ_END]);
+                pollfds[2].events = 0;
+            } else if (n > 0) {
+                if (error_bytes->free < n) {
+                    error_bytes->data = GC_REALLOC(error_bytes->data, (size_t)(error_bytes->length + n));
+                    error_bytes->free = 0;
+                }
+                memcpy(error_bytes->data + error_bytes->length, buf, (size_t)n);
+                error_bytes->length += n;
+            }
+        }
+        if (!did_something) break;
+    }
+
+    int status = 0;
+    if (ret == 0) {
+        while (waitpid(pid, &status, 0) < 0 && errno == EINTR) {
+            if (WIFEXITED(status) || WIFSIGNALED(status))
+                break;
+            else if (WIFSTOPPED(status))
+                kill(pid, SIGCONT);
+        }
+    }
+
+    if (input_bytes.length >= 0) close(child_inpipe[WRITE_END]);
+    if (output_bytes) close(child_outpipe[READ_END]);
+    if (error_bytes) close(child_errpipe[READ_END]);
+
+    sigaction(SIGINT, &oldint, NULL);
+    sigaction(SIGQUIT, &oldquit, NULL);
+    sigprocmask(SIG_SETMASK, &old, NULL);
+
+    if (ret) errno = ret;
+    return status;
+}
+
+typedef struct {
+    pid_t pid;
+    FILE *out;
+} child_info_t;
+
+static void _line_reader_cleanup(child_info_t *child)
+{
+    if (child && child->out) {
+        fclose(child->out);
+        child->out = NULL;
+    }
+    if (child->pid) {
+        kill(child->pid, SIGTERM);
+        child->pid = 0;
+    }
+}
+
+static Text_t _next_line(child_info_t *child)
+{
+    if (!child || !child->out) return NONE_TEXT;
+
+    char *line = NULL;
+    size_t size = 0;
+    ssize_t len = getline(&line, &size, child->out);
+    if (len <= 0) {
+        _line_reader_cleanup(child);
+        return NONE_TEXT;
+    }
+
+    while (len > 0 && (line[len-1] == '\r' || line[len-1] == '\n'))
+        --len;
+
+    if (u8_check((uint8_t*)line, (size_t)len) != NULL)
+        fail("Invalid UTF8!");
+
+    Text_t line_text = Text$from_strn(line, len);
+    free(line);
+    return line_text;
+}
+
+OptionalClosure_t command_by_line(Text_t exe, List_t arg_list, Table_t env_table)
+{
+    posix_spawnattr_t attr;
+    posix_spawnattr_init(&attr);
+
+    int child_outpipe[2];
+    pipe(child_outpipe);
+
+    posix_spawn_file_actions_t actions;
+    posix_spawn_file_actions_init(&actions);
+    posix_spawn_file_actions_adddup2(&actions, child_outpipe[WRITE_END], STDOUT_FILENO);
+    posix_spawn_file_actions_addclose(&actions, child_outpipe[READ_END]);
+
+    const char *exe_str = Text$as_c_string(exe);
+
+    List_t arg_strs = {};
+    List$insert_value(&arg_strs, exe_str, I(0), sizeof(char*));
+    for (int64_t i = 0; i < arg_list.length; i++)
+        List$insert_value(&arg_strs, Text$as_c_string(*(Text_t*)(arg_list.data + i*arg_list.stride)), I(0), sizeof(char*));
+    List$insert_value(&arg_strs, NULL, I(0), sizeof(char*));
+    char **args = arg_strs.data;
+
+    extern char **environ;
+    char **env = environ;
+    if (env_table.entries.length > 0) {
+        List_t env_list = {}; // List of const char*
+        for (char **e = environ; *e; e++)
+            List$insert(&env_list, e, I(0), sizeof(char*));
+
+        for (int64_t i = 0; i < env_table.entries.length; i++) {
+            struct { Text_t key, value; } *entry = env_table.entries.data + env_table.entries.stride*i;
+            const char *env_entry = String(entry->key, "=", entry->value);
+            List$insert(&env_list, &env_entry, I(0), sizeof(char*));
+        }
+        List$insert_value(&env_list, NULL, I(0), sizeof(char*));
+        assert(env_list.stride == sizeof(char*));
+        env = env_list.data;
+    }
+
+    pid_t pid;
+    int ret = exe_str[0] == '/' ?
+        posix_spawn(&pid, exe_str, &actions, &attr, args, env)
+        : posix_spawnp(&pid, exe_str, &actions, &attr, args, env);
+    if (ret != 0)
+        return NONE_CLOSURE;
+
+    posix_spawnattr_destroy(&attr);
+    posix_spawn_file_actions_destroy(&actions);
+
+    close(child_outpipe[WRITE_END]);
+
+    child_info_t *child_info = GC_MALLOC(sizeof(child_info_t));
+    child_info->out = fdopen(child_outpipe[READ_END], "r");
+    child_info->pid = pid;
+    GC_register_finalizer(child_info, (void*)_line_reader_cleanup, NULL, NULL, NULL);
+    return (Closure_t){.fn=(void*)_next_line, .userdata=child_info};
+}
+
+#undef READ_END
+#undef WRITE_END