IO.c

Go to the documentation of this file.

#include "IO.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef _WIN32
#include <windows.h>
#else
#include <unistd.h>
#include <sys/wait.h>
#endif
 
static char **parse_argv(const char *cmd, int *argc)
{
    if (!cmd || !*cmd)
        return NULL;
    size_t len = strlen(cmd);
    char  *copy = malloc(len + 1);
    if (!copy)
        return NULL;
 
#ifdef _WIN32
    strcpy_s(copy, len + 1, cmd);
#else
    strcpy(copy, cmd);
#endif
 
    *argc = 0;
#ifdef _WIN32
    char *context = NULL;
    char *token = strtok_s(copy, " ", &context);
#else
    char *token = strtok(copy, " ");
#endif
    while (token)
    {
        (*argc)++;
#ifdef _WIN32
        token = strtok_s(NULL, " ", &context);
#else
        token = strtok(NULL, " ");
#endif
    }
 
#ifdef _WIN32
    strcpy_s(copy, len + 1, cmd);
#else
    strcpy(copy, cmd);
#endif
 
    char **argv = malloc((*argc + 1) * sizeof(char *));
    if (!argv)
    {
        free(copy);
        return NULL;
    }
 
    int i = 0;
#ifdef _WIN32
    token = strtok_s(copy, " ", &context);
#else
    token = strtok(copy, " ");
#endif
    while (token)
    {
        argv[i] = malloc(strlen(token) + 1);
        if (!argv[i])
        {
            for (int j = 0; j < i; j++)
                free(argv[j]);
            free(argv);
            free(copy);
            return NULL;
        }
#ifdef _WIN32
        strcpy_s(argv[i], strlen(token) + 1, token);
#else
        strcpy(argv[i], token);
#endif
        i++;
#ifdef _WIN32
        token = strtok_s(NULL, " ", &context);
#else
        token = strtok(NULL, " ");
#endif
    }
    argv[i] = NULL;
    free(copy);
    return argv;
}
 
static void free_argv(char **argv)
{
    if (!argv)
        return;
    for (int i = 0; argv[i]; i++)
        free(argv[i]);
    free(argv);
}
 
void c_print_stdout(const char *s, int64_t len)
{
    fwrite(s, 1, (size_t)len, stdout);
}
 
void c_print_stderr(const char *s, int64_t len)
{
    fwrite(s, 1, (size_t)len, stderr);
}
 
int64_t c_system(const char *cmd)
{
    return (int64_t)system(cmd);
}
 
char *c_system_out(const char *cmd)
{
    int    argc;
    char **argv = parse_argv(cmd, &argc);
    if (!argv)
        return NULL;
    char  *output = NULL;
    size_t output_size = 0;
    size_t output_capacity = 1024;
    output = malloc(output_capacity);
    if (!output)
    {
        free_argv(argv);
        return NULL;
    }
#ifdef _WIN32
    SECURITY_ATTRIBUTES sa = {sizeof(SECURITY_ATTRIBUTES), NULL, TRUE};
    HANDLE              hRead, hWrite;
    if (!CreatePipe(&hRead, &hWrite, &sa, 0))
    {
        free(output);
        free_argv(argv);
        return NULL;
    }
    STARTUPINFO si = {0};
    si.cb = sizeof(si);
    si.dwFlags = STARTF_USESTDHANDLES;
    si.hStdOutput = hWrite; // capture stdout
    si.hStdError = GetStdHandle(STD_ERROR_HANDLE);
    si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
    PROCESS_INFORMATION pi;
    if (!CreateProcess(NULL, (char *)cmd, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi))
    {
        CloseHandle(hRead);
        CloseHandle(hWrite);
        free(output);
        free_argv(argv);
        return NULL;
    }
    CloseHandle(hWrite);
    DWORD bytesRead;
    char  buffer[1024];
    while (ReadFile(hRead, buffer, sizeof(buffer), &bytesRead, NULL) && bytesRead > 0)
    {
        if (output_size + bytesRead >= output_capacity)
        {
            output_capacity *= 2;
            char *new_output = realloc(output, output_capacity);
            if (!new_output)
            {
                CloseHandle(hRead);
                CloseHandle(pi.hProcess);
                CloseHandle(pi.hThread);
                free(output);
                free_argv(argv);
                return NULL;
            }
            output = new_output;
        }
        memcpy(output + output_size, buffer, bytesRead);
        output_size += bytesRead;
    }
    output[output_size] = '\0';
    CloseHandle(hRead);
    WaitForSingleObject(pi.hProcess, INFINITE);
    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);
#else
    int pipefd[2];
    if (pipe(pipefd) == -1)
    {
        free(output);
        free_argv(argv);
        return NULL;
    }
    pid_t pid = fork();
    if (pid == -1)
    {
        close(pipefd[0]);
        close(pipefd[1]);
        free(output);
        free_argv(argv);
        return NULL;
    }
    if (pid == 0)
    {
        close(pipefd[0]);
        dup2(pipefd[1], STDOUT_FILENO);
        close(pipefd[1]);
        execvp(argv[0], argv);
        _exit(1);
    }
    else
    {
        close(pipefd[1]);
        ssize_t bytesRead;
        char    buffer[1024];
        while ((bytesRead = read(pipefd[0], buffer, sizeof(buffer))) > 0)
        {
            if (output_size + bytesRead >= output_capacity)
            {
                output_capacity *= 2;
                char *new_output = realloc(output, output_capacity);
                if (!new_output)
                {
                    close(pipefd[0]);
                    free(output);
                    free_argv(argv);
                    return NULL;
                }
                output = new_output;
            }
            memcpy(output + output_size, buffer, bytesRead);
            output_size += bytesRead;
        }
        output[output_size] = '\0';
        close(pipefd[0]);
        int status;
        waitpid(pid, &status, 0);
    }
#endif
    free_argv(argv);
    return output;
}
 
char *c_system_err(const char *cmd)
{
    int    argc;
    char **argv = parse_argv(cmd, &argc);
    if (!argv)
        return NULL;
    char  *output = NULL;
    size_t output_size = 0;
    size_t output_capacity = 1024;
    output = malloc(output_capacity);
    if (!output)
    {
        free_argv(argv);
        return NULL;
    }
#ifdef _WIN32
    SECURITY_ATTRIBUTES sa = {sizeof(SECURITY_ATTRIBUTES), NULL, TRUE};
    HANDLE              hRead, hWrite;
    if (!CreatePipe(&hRead, &hWrite, &sa, 0))
    {
        free(output);
        free_argv(argv);
        return NULL;
    }
    STARTUPINFO si = {0};
    si.cb = sizeof(si);
    si.dwFlags = STARTF_USESTDHANDLES;
    si.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    si.hStdError = hWrite;
    si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
    PROCESS_INFORMATION pi;
    if (!CreateProcess(NULL, (char *)cmd, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi))
    {
        CloseHandle(hRead);
        CloseHandle(hWrite);
        free(output);
        free_argv(argv);
        return NULL;
    }
    CloseHandle(hWrite);
    DWORD bytesRead;
    char  buffer[1024];
    while (ReadFile(hRead, buffer, sizeof(buffer), &bytesRead, NULL) && bytesRead > 0)
    {
        if (output_size + bytesRead >= output_capacity)
        {
            output_capacity *= 2;
            char *new_output = realloc(output, output_capacity);
            if (!new_output)
            {
                CloseHandle(hRead);
                CloseHandle(pi.hProcess);
                CloseHandle(pi.hThread);
                free(output);
                free_argv(argv);
                return NULL;
            }
            output = new_output;
        }
        memcpy(output + output_size, buffer, bytesRead);
        output_size += bytesRead;
    }
    output[output_size] = '\0';
    CloseHandle(hRead);
    WaitForSingleObject(pi.hProcess, INFINITE);
    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);
#else
    int pipefd[2];
    if (pipe(pipefd) == -1)
    {
        free(output);
        free_argv(argv);
        return NULL;
    }
    pid_t pid = fork();
    if (pid == -1)
    {
        close(pipefd[0]);
        close(pipefd[1]);
        free(output);
        free_argv(argv);
        return NULL;
    }
    if (pid == 0)
    {
        close(pipefd[0]);
        dup2(pipefd[1], STDERR_FILENO);
        close(pipefd[1]);
        execvp(argv[0], argv);
        _exit(1);
    }
    else
    {
        close(pipefd[1]);
        ssize_t bytesRead;
        char    buffer[1024];
        while ((bytesRead = read(pipefd[0], buffer, sizeof(buffer))) > 0)
        {
            if (output_size + bytesRead >= output_capacity)
            {
                output_capacity *= 2;
                char *new_output = realloc(output, output_capacity);
                if (!new_output)
                {
                    close(pipefd[0]);
                    free(output);
                    free_argv(argv);
                    return NULL;
                }
                output = new_output;
            }
            memcpy(output + output_size, buffer, bytesRead);
            output_size += bytesRead;
        }
        output[output_size] = '\0';
        close(pipefd[0]);
        int status;
        waitpid(pid, &status, 0);
    }
#endif
    free_argv(argv);
    return output;
}