/*
 * Copyright 2019, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Augustin Cavalier <waddlesplash>
 */

/* Pass this tool a string, and it will parse it into an argv and execvp(). */


#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>


static void
append_char(char c, char** arg, int* argLen, int* argBufferLen)
{
        if ((*argLen + 1) >= *argBufferLen) {
                *arg = realloc(*arg, *argBufferLen + 32);
                if (*arg == NULL) {
                        puts("exec: oom");
                        exit(1);
                }
                *argBufferLen += 32;
        }

        (*arg)[*argLen] = c;
        (*argLen)++;
}


static void
parse_quoted(const char* str, int* pos, char** currentArg, int* currentArgLen,
        int* currentArgBufferLen)
{
        char end = str[*pos];
        while (1) {
                char c;
                (*pos)++;
                c = str[*pos];
                if (c == '\0') {
                        puts("exec: mismatched quotes");
                        exit(1);
                }
                if (c == end)
                        break;

                switch (c) {
                case '\\':
                        (*pos)++;
                        // fall through
                default:
                        append_char(str[*pos], currentArg, currentArgLen,
                                currentArgBufferLen);
                break;
                }
        }
}


int
main(int argc, const char* argv[])
{
        char** args = NULL, *currentArg = NULL;
        const char* str;
        int argsLen = 0, argsBufferLen = 0, currentArgLen = 0,
                currentArgBufferLen = 0, encounteredNewlineAt = -1,
                modifiedEnvironment = 0, pos;

        if (argc != 2) {
                printf("usage: %s \"program arg 'arg1' ...\"\n", argv[0]);
                return 1;
        }

        str = argv[1];
        pos = 0;
        while (1) {
                switch (str[pos]) {
                case '\r':
                case '\n':
                        // In normal shells, this would imply a second command.
                        // We don't support that here, so we need to make sure
                        // that either we have not parsed any arguments yet,
                        // or there are no more arguments pushed after this.
                        if (argsLen == 0 && currentArgLen == 0 && !modifiedEnvironment)
                                break;
                        encounteredNewlineAt = argsLen + 1;
                        // fall through
                case ' ':
                case '\t':
                case '\0':
                        if (currentArgLen == 0)
                                break; // do nothing
                        if (encounteredNewlineAt == argsLen) {
                                puts("exec: running multiple commands not supported!");
                                return 1;
                        }

                        // the current argument hasn't been terminated, do that now
                        append_char('\0', &currentArg, &currentArgLen,
                                &currentArgBufferLen);

                        // handle environs
                        {
                        char* val;
                        if (argsLen == 0 && (val = strstr(currentArg, "=")) != NULL) {
                                const char* dollar;
                                char* newVal = NULL;
                                *val = '\0';
                                val++;

                                // handle trivial variable substitution, i.e. VAL=$VAL:...
                                dollar = strstr(val, "$");
                                if (dollar != NULL) {
                                        const char* oldVal;
                                        int oldValLen, valLen, nameLen;

                                        if (dollar != val) {
                                                puts("exec: environ expansion not at start of "
                                                        "line unsupported");
                                                return 1;
                                        }
                                        val++; // skip the $
                                        valLen = strlen(val);
                                        nameLen = strlen(currentArg);

                                        // if the new value does not start with the environ name
                                        // (which is broken by a non-alphanumeric character), bail.
                                        if (strncmp(val, currentArg, nameLen) != 0
                                                        || isalnum(val[nameLen])) {
                                                puts("exec: environ expansion of other variables "
                                                        "unsupported");
                                                return 1;
                                        }

                                        // get the old value and actually do the expansion
                                        oldVal = getenv(currentArg);
                                        oldValLen = strlen(oldVal);
                                        newVal = malloc(valLen + oldValLen + 1);
                                        memcpy(newVal, oldVal, oldValLen);
                                        memcpy(newVal + oldValLen, val + nameLen, valLen + 1);
                                        val = newVal;
                                }

                                setenv(currentArg, val, 1);
                                free(newVal);
                                modifiedEnvironment = 1;

                                free(currentArg);
                                currentArg = NULL;
                                currentArgLen = 0;
                                currentArgBufferLen = 0;
                                break;
                        }
                        }

                        // actually add the argument to the array
                        if ((argsLen + 2) >= argsBufferLen) {
                                args = realloc(args, (argsBufferLen + 8) * sizeof(char*));
                                if (args == NULL) {
                                        puts("exec: oom");
                                        return 1;
                                }
                                argsBufferLen += 8;
                        }

                        args[argsLen] = currentArg;
                        args[argsLen + 1] = NULL;
                        argsLen++;

                        currentArg = NULL;
                        currentArgLen = 0;
                        currentArgBufferLen = 0;
                break;

                case '\'':
                case '"':
                        parse_quoted(str, &pos, &currentArg, &currentArgLen,
                                &currentArgBufferLen);
                break;

                case '\\':
                        pos++;
                        // don't append newlines to the current argument
                        if (str[pos] == '\r' || str[pos] == '\n')
                                break;
                        // fall through
                default:
                        append_char(str[pos], &currentArg, &currentArgLen,
                                &currentArgBufferLen);
                break;
                }
                if (str[pos] == '\0')
                        break;
                pos++;
        }

        pos = execvp(args[0], args);
        if (pos != 0)
                printf("exec failed: %s\n", strerror(errno));
        return pos;
}