Luna/apps/src/sh.c

#include <assert.h>
#include <errno.h>
#include <luna.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>

static int status = 0;

typedef struct
{
    char* buffer;
    size_t size;
    size_t capacity;
} command;

char** split_command_into_argv(const char* cmd)
{
    size_t argc = 1;
    char* ptr = strdup(cmd);
    char* endptr;
    char** arr = calloc(sizeof(char*), argc);
    for (;;)
    {
        endptr = strchr(ptr, ' ');
        arr[argc - 1] = ptr;
        if (endptr == NULL) break;
        *endptr = 0;
        ptr = endptr + 1;
        if (*ptr)
        {
            argc++;
            arr = realloc(arr, sizeof(char*) * argc);
        }
        else
            break;
    }
    argc++;
    arr = realloc(arr, sizeof(char*) * argc);
    arr[argc - 1] = NULL;
    return arr;
}

char* shell_concat_path(const char* dirname, const char* basename)
{
    char* buf = malloc(strlen(basename) + strlen(dirname) + 6);
    strlcpy(buf, dirname, strlen(dirname) + 1);
    strncat(buf, basename, strlen(basename));
    return buf;
}

void shell_execvp(char* pathname, char* const argv[])
{
    char* new_path;
    if (access(pathname, F_OK) == 0)
    {
        execv(pathname, argv);
        return;
    }
    if (pathname[0] == '/') return; // We do not want to lookup absolute paths
    new_path = shell_concat_path("/bin/", pathname);
    if (access(new_path, F_OK) == 0)
    {
        execv(new_path, argv);
        return;
    }
    free(new_path);
    new_path = shell_concat_path("/usr/bin/", pathname);
    execv(new_path, argv);
    int saved = errno;
    free(new_path);
    errno = saved;
}

void show_prompt()
{
    if (WEXITSTATUS(status)) { printf("%d [%ld]> ", WEXITSTATUS(status), getpid()); }
    else
        printf("[%ld]> ", getpid());
}

int command_matches(command* cmd, const char* string)
{
    if (cmd->size <= strlen(string)) // cmd->size includes null terminator
        return 0;
    return strncmp(cmd->buffer, string, strlen(string)) == 0;
}

int command_matches_exactly(command* cmd, const char* string)
{
    if (cmd->size <= strlen(string)) // cmd->size includes null terminator
        return 0;
    if (cmd->size > (strlen(string) + 1)) return 0;
    return strncmp(cmd->buffer, string, strlen(string)) == 0;
}

int command_match_builtins(command* cmd)
{
    if (command_matches(cmd, "exit ")) { exit(atoi(cmd->buffer + 5)); }
    if (command_matches_exactly(cmd, "exit")) { exit(0); }
    if (command_matches_exactly(cmd, "pid"))
    {
        printf("pid %ld, ppid %ld\n", getpid(), getppid());
        return 1;
    }
    return 0;
}

void command_expand(command* cmd, long new_capacity)
{
    char* buffer = realloc(cmd->buffer, new_capacity);
    if (!buffer)
    {
        perror("realloc");
        exit(1);
    }
    cmd->buffer = buffer;
    cmd->capacity = new_capacity;
}

void command_push(command* cmd, char c)
{
    if (cmd->size == cmd->capacity) command_expand(cmd, cmd->capacity + 8);
    cmd->buffer[cmd->size] = c;
    cmd->size++;
}

void command_pop(command* cmd)
{
    cmd->size--;
}

void command_init(command* cmd)
{
    cmd->buffer = malloc(5);
    cmd->capacity = 5;
    cmd->size = 0;
}

void command_clear(command* cmd)
{
    free(cmd->buffer);
    return command_init(cmd);
}

void command_execute(command* cmd)
{
    command_push(cmd, '\0');
    if (command_match_builtins(cmd))
    {
        command_clear(cmd);
        show_prompt();
        return;
    }
    pid_t child = fork();
    if (child < 0)
    {
        perror("fork");
        command_clear(cmd);
        show_prompt();
        return;
    }
    if (child == 0)
    {
        char** argv = split_command_into_argv(cmd->buffer);
        shell_execvp(argv[0], argv);
        perror(argv[0]);
        exit(127);
    }
    pid_t result;
    while ((result = waitpid(child, &status, 0)) == 0) { msleep(20); }
    if (result < 0)
    {
        perror("waitpid");
        command_clear(cmd);
        show_prompt();
        return;
    }
    int exit_status = WEXITSTATUS(status);
    if (exit_status == -2 || exit_status == -3) printf("(PID %ld) Segmentation fault\n", result);
    command_clear(cmd);
    show_prompt();
}

void command_concat_char(command* cmd, char c)
{
    if (c == '\b')
    {
        if (cmd->size != 0)
        {
            putchar(c);
            command_pop(cmd);
        }
    }
    else if (c == '\n')
    {
        putchar(c);
        if (cmd->size == 0)
        {
            status = 0;
            show_prompt();
        }
        else
            command_execute(cmd);
    }
    else
    {
        putchar(c);
        command_push(cmd, c);
    }
}

void command_concat(command* cmd, const char* str)
{
    while (*str)
    {
        command_concat_char(cmd, *str);
        str++;
    }
}

int main()
{
    show_prompt();

    command shell_command;
    command_init(&shell_command);

    while (1)
    {
        int c = getchar();
        if (c == EOF)
        {
            if (ferror(stdin))
            {
                perror("getchar");
                return 1;
            }
            if (feof(stdin)) return 0;
            assert(false); // we should never get here
        }
        command_concat_char(&shell_command, (char)c);
    }
}