modfetch/modfetch.c

#include "mod.h"
#include "semver.h"
#include <ctype.h>
#include <dlfcn.h>
#include <errno.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <wordexp.h>

static const char *PNAME = "modfetch";

static const semver VERSION = {
    .major = 0,
    .minor = 1,
    .patch = 0,
};

static const uint8_t MAX_MODULE_NAME_LENGTH = 128;
static const uint8_t MAX_MODULES = 128;

static const uint8_t INITIAL_CONFIG_SIZE = 8;

static const uint16_t MAX_PATH_LENGTH = 4096;

typedef struct {
    // path to the binary of this module
    char *path;
    // name=value strings for each value in config
    char **config;
} Module;

typedef struct {
    size_t module_count;
    Module *modules;
} Config;

void parsing_error(size_t line) {
    fprintf(stderr, "error: failed parsing config at line %zu", line);
    exit(EXIT_FAILURE);
}

char *remove_whitespaces(const char *str) {
    char tmp[strlen(str)];
    size_t i = 0;
    size_t j = 0;
    while (str[i] != '\0') {
        if (isspace(str[i])) {
            i += 1;
            continue;
        }
        tmp[j] = str[i];
        i += 1;
        j += 1;
    }

    char *ret = malloc(j * sizeof(char));
    strncpy(ret, tmp, j);
    ret[j] = '\0';

    return ret;
}

char *resolve_env_vars(const char *str) {
    size_t len = strlen(str);
    char *ret = malloc(MAX_PATH_LENGTH * sizeof(char));
    size_t ret_offset = 0;
    bool in_env_var = false;
    char env_var[MAX_PATH_LENGTH];
    memset(env_var, 0, sizeof(env_var));
    size_t env_var_offset = 0;

    for (size_t i = 0; i < len; ++i) {
        if (str[i] == '~') {
            char *home = getenv("HOME");
            strcat(ret, home);
            ret_offset += strlen(home);
            continue;
        }
        
        if (str[i] == '$') {
            in_env_var = true;
            continue;
        }

        // end of current env var
        if (in_env_var && !(isalpha(str[i]) || isdigit(str[i]) || str[i] == '_')) {
            in_env_var = false;

            char *env = getenv(env_var);
            strcat(ret, env);
            ret_offset += strlen(env);
            memset(env_var, 0, sizeof(env_var));
            env_var_offset = 0;
        }

        if (in_env_var) {
            env_var[env_var_offset] = str[i];
            env_var_offset += 1;
            continue;
        }

        ret[ret_offset] = str[i];
        ret_offset += 1;
    }
    ret[ret_offset] = '\0';

    return ret;
}

char *process_str(const char *str) {
    char *whitespaceless = remove_whitespaces(str);
    char *ret = resolve_env_vars(whitespaceless);
    free(whitespaceless);
    return ret;
}

Config parse_config(FILE *config_file) {
    size_t len = 0;
    ssize_t read;
    char *line = NULL;
    size_t line_index = 0;
    bool in_config = false; 

    char current_path[MAX_MODULE_NAME_LENGTH];
    Module current_module = {
        .path = NULL,
        .config = NULL,
    };
    size_t config_index = 0;
    size_t config_multiplier = 1;
    
    Config config = {
        .modules = malloc(MAX_MODULES * sizeof(Module)),
        .module_count = 0,
    };

    // TODO handle errors of all the function inside the while
    errno = 0;

    // TODO rewrite this to read the config char by char
    while ((read = getline(&line, &len, config_file)) != -1) {
        if (read <= 1)
            continue;

        // if config is passed to this module
        if (line[read - 2u] == '{') {
            if (in_config) {
                fclose(config_file);
                parsing_error(line_index);
            }
            in_config = true;
            // get rid of the '{'
            strncpy(current_path, line, (size_t)read - 2);
            current_path[read - 2] = '\0';

            current_module.path = process_str(current_path);
            current_module.config = malloc(INITIAL_CONFIG_SIZE * sizeof(char*));
            continue;
        }

        // end of config for current module
        if (line[read - 2u] == '}') {
            if (!in_config) {
                fclose(config_file);
                parsing_error(line_index);
            }
            in_config = false;

            if (config_index >= INITIAL_CONFIG_SIZE * config_multiplier) {
                config_multiplier *= 2;
                current_module.config = realloc(current_module.config, INITIAL_CONFIG_SIZE * config_multiplier);
            }
            current_module.config[config_index] = NULL;
            config.modules[config.module_count] = current_module;
            config.module_count += 1;
            config_index = 0;
            continue;
        }

        if (in_config) {
            if (config_index >= INITIAL_CONFIG_SIZE * config_multiplier) {
                config_multiplier *= 2;
                current_module.config = realloc(current_module.config, INITIAL_CONFIG_SIZE * config_multiplier);
            }
            current_module.config[config_index] = process_str(line);
            config_index += 1;
            continue;
        }

        // no config passed to this module
        current_module.path = process_str(line);

        current_module.config = malloc(sizeof(void*));
        current_module.config[0] = NULL;

        config.modules[config.module_count] = current_module;
        config.module_count += 1;

        free(line);
    }
    if (read == -1 && errno != 0)
        free(line);

    return config;
}

int main(int argc, char *argv[]) {

    char *config_path;
    char *config_dir = getenv("XDG_CONFIG_HOME");
    if (config_dir == NULL) {
        char *home = getenv("$HOME");
        if (asprintf(&config_dir, "%s/.config", home) < 0) {
            fprintf(stderr, "error: failed formatting config dir (this shouldn't happen)");
            exit(EXIT_FAILURE);
        }
    }

    if (asprintf(&config_path, "%s/modfetch.conf", config_dir) < 0) {
        fprintf(stderr, "error: failed formatting config path (this shouldn't happen)");
        exit(EXIT_FAILURE);
    }

    for (size_t i = 1; i < (size_t)argc; ++i) {
        if (strcmp(argv[i], "-c") == 0 || strcmp(argv[i], "--config") == 0) {
            if (i == (size_t)argc - 1) {
                fprintf(stderr, "error: no config path passed\n");
                exit(EXIT_FAILURE);
            }

            i += 1;
            config_path = argv[i];
            continue;
        }

        if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) {
            fprintf(stderr, "%s: modular fetch [%s]\n", PNAME, svtoa(VERSION));
            fprintf(stderr, "\n");
            fprintf(stderr, "OPTIONS\n");
            fprintf(stderr, "\t-h, --help\t\t\tdisplays this help text\n");
            fprintf(stderr, "\t-c, --config /path/to/config\tchanges config path from the default ($XDG_CONFIG_HOME/%s.conf)\n", PNAME);
            exit(EXIT_SUCCESS);
        }
    }

    FILE *config_file = fopen(config_path, "r");

    if (config_file == NULL) {
        fprintf(stderr, "error: failed to open config at: %s\n", config_path);
        exit(EXIT_FAILURE);
    }

    Config config = parse_config(config_file);

    fclose(config_file);
    free(config_path);

    for (size_t i = 0; i < config.module_count; ++i) {
        Module current_module = config.modules[i];
        void *handle = dlopen(current_module.path, RTLD_NOW);
        if (handle == NULL) {
            fprintf(stderr, "error: failed opening module %s\n", current_module.path);
            fprintf(stderr, "%s\n", dlerror());
            exit(EXIT_FAILURE);
        }
        dlerror();

        // stupid fucking c standard issue
        // I'm not fixing this
        // https://stackoverflow.com/questions/14134245/iso-c-void-and-function-pointers
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
        semver (*mod_version)(void) = dlsym(handle, "version");
        const char *(*mod_name)(void) = dlsym(handle, "name");
        const char *(*mod_get)(void) = dlsym(handle, "get");
        void (*mod_init)(semver, char**) = dlsym(handle, "init");
#pragma GCC diagnostic pop

        mod_init(API_VERSION, current_module.config);

        (void)mod_name;
        (void)mod_version;
        // printf("%s: %s\n", mod_name(), svtoa(mod_version()));
        printf("%s\n", mod_get());
    }

    return 0;
}