aos/usr/shelly/shelly_cmd.c

#include <stdlib.h>
#include <fs/fs.h>
#include <fs/dirent.h>
#include "shelly.h"

__attribute__((__used__))
static void parse_cmd_line(char * line, int * argc, char ** argv) {
    *argc = 0;
    char *token = strtok(line, " ");
    while (token != NULL) {
        argv[*argc] = token;
        token = strtok(NULL, " ");
        *argc += 1;
    }
}

static errval_t shelly_cmd_help(char * line) {
    errval_t err;
    err = shelly_write_str("commands implemented:\n\r");
    if (err_is_fail(err)) return err;
    err = shelly_write_str("- echo [string]\n\r");
    if (err_is_fail(err)) return err;
    err = shelly_write_str("- run [core] [binary]\n\r");
    if (err_is_fail(err)) return err;
    err = shelly_write_str("    run a module from bootinfo\n\r");
    if (err_is_fail(err)) return err;
    err = shelly_write_str("- ps\n\r");
    if (err_is_fail(err)) return err;
    err = shelly_write_str("- ls\n\r");
    if (err_is_fail(err)) return err;
    err = shelly_write_str("- cat\n\r");
    if (err_is_fail(err)) return err;
    err = shelly_write_str("    ...meow\n\r");
    if (err_is_fail(err)) return err;
    err = shelly_write_str("- mkdir\n\r");
    if (err_is_fail(err)) return err;
    err = shelly_write_str("- rmdir\n\r");
    if (err_is_fail(err)) return err;
    err = shelly_write_str("- help\n\r");
    if (err_is_fail(err)) return err;

    return SYS_ERR_OK;
}

static errval_t shelly_cmd_ls(char * line) {
    errval_t err;

    fs_dirhandle_t dh;
    err = opendir(line, &dh);
    if (err_is_fail(err)) {
        return err;
    }

    if (dh == NULL) {
        return SHELLY_ERR_FILE_NOT_FOUND;
    }

    char buf[256];

    do {
        char *name;
        err = readdir(dh, &name);
        if (err_no(err) == FS_ERR_INDEX_BOUNDS) {
            break;
        } else if (err_is_fail(err)) {
            goto err_out;
        }
        snprintf(buf, 256, "%s\n\r", name);
        err = shelly_write_str(buf);
        if (err_is_fail(err)) goto err_out;
    } while(err_is_ok(err));

    return closedir(dh);
    err_out:
    return err;
}

static errval_t shelly_cmd_cat(char * line) {
    errval_t err;

    err = shelly_write_str("    /\\_/\\           ___\n\r");
    if (err_is_fail(err)) return err;
    err = shelly_write_str("   = o_o =_______    \\ \\\n\r");
    if (err_is_fail(err)) return err;
    err = shelly_write_str("    __^      __(  \\.__) )\n\r");
    if (err_is_fail(err)) return err;
    err = shelly_write_str("(@)<_____>__(_____)____/\n\r");
    if (err_is_fail(err)) return err;

    return SYS_ERR_OK;
}

static errval_t shelly_cmd_mkdir(char * line) {
    return mkdir(line);
}

static errval_t shelly_cmd_rmdir(char * line) {
    return rmdir(line);
}

static errval_t shelly_cmd_echo(char * line) {
    errval_t err;
    err = shelly_write_str(line);
    if (err_is_fail(err)) return err;
    return SYS_ERR_OK;
}

static errval_t shelly_cmd_run(char * line) {
    errval_t err;

    SHELLY_DEBUG("[shelly_cmd_run] line=%s\n", line);

    char * module_line;
    long core_id = strtol(line, &module_line, 10);
    module_line += 1;
    // start process
    domainid_t pid;
    struct aos_rpc * rpc = aos_rpc_get_process_channel();
    err = aos_rpc_process_spawn(rpc, module_line, core_id, &pid);
    if (err == SPAWN_ERR_FIND_MODULE) {
        err = shelly_write_str("[run] couldn't find module:\n\r");
        if (err_is_fail(err)) return err;
        err = shelly_write_str(line);
        if (err_is_fail(err)) return err;
        err = shelly_write_str("\n\r");
        if (err_is_fail(err)) return err;
    } else if (err_is_fail(err)) return err_push(err, SHELLY_ERR_SPAWN_RPC);

    return SYS_ERR_OK;
}

static errval_t shelly_cmd_ps(char * line) {
    errval_t err;

    domainid_t *pids;
    size_t pid_count;
    struct aos_rpc * rpc = aos_rpc_get_process_channel();
    err = aos_rpc_process_get_all_pids(rpc, &pids, &pid_count);
    if (err_is_fail(err)) return err_push(err, SHELLY_ERR_PS_RPC);
    shelly_write_str("PIDs:\n\r");
    char buf[256];
    for(size_t i = 0; i < pid_count; ++i) {
        // get process name
        char *name;
        err = aos_rpc_process_get_name(rpc, pids[i], &name);
        if (err_is_fail(err)) name = "unknown name";
        snprintf(buf, 256, " %lu : %s\n\r", pids[i], name);
        shelly_write_str(buf);
    }
    return SYS_ERR_OK;
}

static errval_t handle_shelly_cmd(char* line, size_t len) {
    // SHELLY_DEBUG("[handle_shelly_cmd] len=%d\n", len);
    if (len <= 1) {
        return SYS_ERR_OK;
    }

    char * cmd = strtok(line, " ");

    char * remaining_line = line + strlen(cmd) + 1;

    // debug_printf("remaining_line = %s\n", remaining_line);

    if (strcmp(cmd, "echo") == 0) {
        return shelly_cmd_echo(remaining_line);
    } else if (strcmp(cmd, "run") == 0) {
        return shelly_cmd_run(remaining_line);
    } else if (strcmp(cmd, "ps") == 0) {
        return shelly_cmd_ps(remaining_line);
    } else if (strcmp(cmd, "help") == 0) {
        return shelly_cmd_help(remaining_line);
    } else if (strcmp(cmd, "ls") == 0) {
        return shelly_cmd_ls(remaining_line);
    } else if (strcmp(cmd, "cat") == 0) {
        return shelly_cmd_cat(remaining_line);
    } else if (strcmp(cmd, "mkdir") == 0) {
        return shelly_cmd_mkdir(remaining_line);
    } else if (strcmp(cmd, "rmdir") == 0) {
        return shelly_cmd_rmdir(remaining_line);
    } else {
        char buf[256];
        snprintf(buf, 256, "unknown command \"%s\"\n\r", cmd);
        shelly_write_str(buf);
    }

    return SYS_ERR_OK;
}