source: bootcd/isolinux/syslinux-6.03/com32/hdt/hdt-cli.c

/* ----------------------------------------------------------------------- *
 *
 *   Copyright 2009 Erwan Velu - All Rights Reserved
 *
 *   Permission is hereby granted, free of charge, to any person
 *   obtaining a copy of this software and associated documentation
 *   files (the "Software"), to deal in the Software without
 *   restriction, including without limitation the rights to use,
 *   copy, modify, merge, publish, distribute, sublicense, and/or
 *   sell copies of the Software, and to permit persons to whom
 *   the Software is furnished to do so, subject to the following
 *   conditions:
 *
 *   The above copyright notice and this permission notice shall
 *   be included in all copies or substantial portions of the Software.
 *
 *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 *   OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 *   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 *   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 *   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 *   OTHER DEALINGS IN THE SOFTWARE.
 *
 * -----------------------------------------------------------------------
 */

#include <stdlib.h>
#include <string.h>
#include <syslinux/config.h>
#include <getkey.h>
#include <acpi/acpi.h>
#include "hdt-cli.h"
#include "hdt-common.h"

struct cli_mode_descr *list_modes[] = {
    &hdt_mode,
    &dmi_mode,
    &syslinux_mode,
    &pxe_mode,
    &kernel_mode,
    &cpu_mode,
    &pci_mode,
    &vesa_mode,
    &disk_mode,
    &vpd_mode,
    &memory_mode,
    &acpi_mode,
    NULL,
};

/*
 * .aliases = {"q", "quit"} won't work since it is an array of pointers, not an
 * array of variables. There is no easy way around it besides declaring the arrays of
 * strings first.
 */
const char *exit_aliases[] = { "q", "quit" };
const char *help_aliases[] = { "h", "?" };

/* List of aliases */
struct cli_alias hdt_aliases[] = {
    {
     .command = CLI_EXIT,
     .nb_aliases = 2,
     .aliases = exit_aliases,
     },
    {
     .command = CLI_HELP,
     .nb_aliases = 2,
     .aliases = help_aliases,
     },
};

struct cli_mode_descr *current_mode;
int autocomplete_backlog;

struct autocomplete_list {
    char autocomplete_token[MAX_LINE_SIZE];
    struct autocomplete_list *next;
};
struct autocomplete_list *autocomplete_head = NULL;
struct autocomplete_list *autocomplete_tail = NULL;
struct autocomplete_list *autocomplete_last_seen = NULL;

static void autocomplete_add_token_to_list(const char *token)
{
    struct autocomplete_list *new = malloc(sizeof(struct autocomplete_list));

    strlcpy(new->autocomplete_token, token, sizeof(new->autocomplete_token));
    new->next = NULL;
    autocomplete_backlog++;

    if (autocomplete_tail != NULL)
        autocomplete_tail->next = new;
    if (autocomplete_head == NULL)
        autocomplete_head = new;
    autocomplete_tail = new;
}

static void autocomplete_destroy_list(void)
{
    struct autocomplete_list *tmp = NULL;

    while (autocomplete_head != NULL) {
        tmp = autocomplete_head->next;
        free(autocomplete_head);
        autocomplete_head = tmp;
    }
    autocomplete_backlog = 0;
    autocomplete_tail = NULL;
    autocomplete_last_seen = NULL;
}

/**
 * set_mode - set the current mode of the cli
 * @mode:       mode to set
 *
 * Unlike cli_set_mode, this function is not used by the cli directly.
 **/
void set_mode(cli_mode_t mode, struct s_hardware *hardware)
{
    int i = 0;

    switch (mode) {
    case EXIT_MODE:
        hdt_cli.mode = mode;
        break;
    case HDT_MODE:
        hdt_cli.mode = mode;
        snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_HDT);
        break;
    case PXE_MODE:
        if (hardware->sv->filesystem != SYSLINUX_FS_PXELINUX) {
            more_printf("You are not currently using PXELINUX\n");
            break;
        }
        hdt_cli.mode = mode;
        snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_PXE);
        break;
    case KERNEL_MODE:
        hdt_cli.mode = mode;
        snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_KERNEL);
        break;
    case SYSLINUX_MODE:
        hdt_cli.mode = mode;
        snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_SYSLINUX);
        break;
    case VESA_MODE:
        hdt_cli.mode = mode;
        snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_VESA);
        break;
    case PCI_MODE:
        hdt_cli.mode = mode;
        snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_PCI);
        break;
    case CPU_MODE:
        hdt_cli.mode = mode;
        snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_CPU);
        break;
    case DMI_MODE:
        if (!hardware->is_dmi_valid) {
            more_printf("No valid DMI table found, exiting.\n");
            break;
        }
        hdt_cli.mode = mode;
        snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_DMI);
        break;
    case DISK_MODE:
        hdt_cli.mode = mode;
        snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_DISK);
        break;
    case VPD_MODE:
        if (!hardware->is_vpd_valid) {
            more_printf("No valid VPD table found, exiting.\n");
            break;
        }
        hdt_cli.mode = mode;
        snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_VPD);
        break;
    case MEMORY_MODE:
        hdt_cli.mode = mode;
        snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_MEMORY);
        break;
    case ACPI_MODE:
        hdt_cli.mode = mode;
        snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_ACPI);
        break;
    default:
        /* Invalid mode */
        more_printf("Unknown mode, please choose among:\n");
        while (list_modes[i]) {
            more_printf("\t%s\n", list_modes[i]->name);
            i++;
        }
    }

    find_cli_mode_descr(hdt_cli.mode, &current_mode);
    /* There is not cli_mode_descr struct for the exit mode */
    if (current_mode == NULL && hdt_cli.mode != EXIT_MODE) {
        /* Shouldn't get here... */
        more_printf("!!! BUG: Mode '%d' unknown.\n", hdt_cli.mode);
    }
}

/**
 * mode_s_to_mode_t - given a mode string, return the cli_mode_t representation
 **/
cli_mode_t mode_s_to_mode_t(char *name)
{
    int i = 0;

    while (list_modes[i]) {
        if (!strncmp(name, list_modes[i]->name, sizeof(list_modes[i]->name)))
            break;
        i++;
    }

    if (!list_modes[i])
        return INVALID_MODE;
    else
        return list_modes[i]->mode;
}

/**
 * find_cli_mode_descr - find the cli_mode_descr struct associated to a mode
 * @mode:       mode to look for
 * @mode_found: store the mode if found, NULL otherwise
 *
 * Given a mode name, return a pointer to the associated cli_mode_descr
 * structure.
 * Note: the current mode name is stored in hdt_cli.mode.
 **/
void find_cli_mode_descr(cli_mode_t mode, struct cli_mode_descr **mode_found)
{
    int i = 0;

    while (list_modes[i] && list_modes[i]->mode != mode)
        i++;

    /* Shouldn't get here... */
    if (!list_modes[i])
        *mode_found = NULL;
    else
        *mode_found = list_modes[i];
}

/**
 * expand_aliases - resolve aliases mapping
 * @line:       command line to parse
 * @command:    first token in the line
 * @module:     second token in the line
 * @argc:       number of arguments
 * @argv:       array of arguments
 *
 * We maintain a small list of static alises to enhance user experience.
 * Only commands can be aliased (first token). Otherwise it can become really hairy...
 **/
static void expand_aliases(char *line __unused, char **command, char **module,
                           int *argc, char **argv)
{
    struct cli_mode_descr *mode;
    int i, j;

    find_cli_mode_descr(mode_s_to_mode_t(*command), &mode);
    if (mode != NULL && *module == NULL) {
        /*
         * The user specified a mode instead of `set mode...', e.g.
         * `dmi' instead of `set mode dmi'
         */

        /* *argv is NULL since *module is NULL */
        *argc = 1;
        *argv = malloc(*argc * sizeof(char *));
        argv[0] = malloc((sizeof(*command) + 1) * sizeof(char));
        strlcpy(argv[0], *command, sizeof(*command) + 1);
        dprintf("CLI DEBUG: ALIAS %s ", *command);

        strlcpy(*command, CLI_SET, sizeof(CLI_SET));    /* set */

        *module = malloc(sizeof(CLI_MODE) * sizeof(char));
        strlcpy(*module, CLI_MODE, sizeof(CLI_MODE));   /* mode */

        dprintf("--> %s %s %s\n", *command, *module, argv[0]);
        goto out;
    }

    /* Simple aliases mapping a single command to another one */
    for (i = 0; i < MAX_ALIASES; i++) {
        for (j = 0; j < hdt_aliases[i].nb_aliases; j++) {
            if (!strncmp(*command, hdt_aliases[i].aliases[j],
                         sizeof(hdt_aliases[i].aliases[j]))) {
                dprintf("CLI DEBUG: ALIAS %s ", *command);
                strlcpy(*command, hdt_aliases[i].command,
                        sizeof(hdt_aliases[i].command) + 1);
                dprintf("--> %s\n", *command);
                goto out;       /* Don't allow chaining aliases */
            }
        }
    }
    return;

out:
    dprintf("CLI DEBUG: New parameters:\n");
    dprintf("CLI DEBUG: command = %s\n", *command);
    dprintf("CLI DEBUG: module  = %s\n", *module);
    dprintf("CLI DEBUG: argc    = %d\n", *argc);
    for (i = 0; i < *argc; i++)
        dprintf("CLI DEBUG: argv[%d] = %s\n", i, argv[0]);
    return;
}

/**
 * parse_command_line - low level parser for the command line
 * @line:       command line to parse
 * @command:    first token in the line
 * @module:     second token in the line
 * @argc:       number of arguments
 * @argv:       array of arguments
 *
 * The format of the command line is:
 *      <main command> [<module on which to operate> [<args>]]
 *      command is always malloc'ed (even for an empty line)
 **/
static void parse_command_line(char *line, char **command, char **module,
                               int *argc, char **argv)
{
    int argc_iter = 0, args_pos = 0, token_found = 0, token_len = 0;
    int args_len = 0;
    char *pch = NULL, *pch_next = NULL, *tmp_pch_next = NULL;

    *command = NULL;
    *module = NULL;
    *argc = 0;

    pch = line;
    while (pch != NULL) {
        pch_next = strchr(pch + 1, ' ');
        tmp_pch_next = pch_next;

        /*
         * Skip whitespaces if the user entered
         * 'set   mode        foo' for 'set mode foo'
         *  ^   ^
         *  |___|___ pch
         *      |___ pch_next <- wrong!
         *
         *  We still keep the position into tmp_pch_next to compute
         *  the lenght of the current token.
         */
        while (pch_next != NULL && !strncmp(pch_next, CLI_SPACE, 1))
            pch_next++;

        /* End of line guaranteed to be zeroed */
        if (pch_next == NULL) {
            token_len = (int)(strchr(pch + 1, '\0') - pch);
            args_len = token_len;
        } else {
            token_len = (int)(tmp_pch_next - pch);
            args_len = (int)(pch_next - pch);
        }

        if (token_found == 0) {
            /* Main command to execute */
            *command = malloc((token_len + 1) * sizeof(char));
            strlcpy(*command, pch, token_len);
            (*command)[token_len] = '\0';
            dprintf("CLI DEBUG parse: command = %s\n", *command);
            args_pos += args_len;
        } else if (token_found == 1) {
            /* Module */
            *module = malloc((token_len + 1) * sizeof(char));
            strlcpy(*module, pch, token_len);
            (*module)[token_len] = '\0';
            dprintf("CLI DEBUG parse: module  = %s\n", *module);
            args_pos += args_len;
        } else
            (*argc)++;

        token_found++;
        pch = pch_next;
    }
    dprintf("CLI DEBUG parse: argc    = %d\n", *argc);

    /* Skip arguments handling if none is supplied */
    if (!*argc)
        return;

    /* Transform the arguments string into an array */
    *argv = malloc(*argc * sizeof(char *));
    pch = strtok(line + args_pos, CLI_SPACE);
    while (pch != NULL) {
        dprintf("CLI DEBUG parse: argv[%d] = %s\n", argc_iter, pch);
        argv[argc_iter] = malloc(strlen(pch) * sizeof(char));
        strlcpy(argv[argc_iter], pch, strlen(pch));
        argc_iter++;
        pch = strtok(NULL, CLI_SPACE);
        /*
         * strtok(NULL, CLI_SPACE) over a stream of spaces
         * will return an empty string
         */
        while (pch != NULL && !strncmp(pch, "", 1))
            pch = strtok(NULL, CLI_SPACE);
    }
}

/**
 * find_cli_callback_descr - find a callback in a list of modules
 * @module_name:        Name of the module to find
 * @modules_list:       Lits of modules among which to find @module_name
 * @module_found:       Pointer to the matched module, NULL if not found
 *
 * Given a module name and a list of possible modules, find the corresponding
 * module structure that matches the module name and store it in @module_found.
 **/
void find_cli_callback_descr(const char *module_name,
                             struct cli_module_descr *modules_list,
                             struct cli_callback_descr **module_found)
{
    int modules_iter = 0;

    if (modules_list == NULL)
        goto not_found;

    /* Find the callback to execute */
    while (modules_list->modules[modules_iter].name &&
           strcmp(module_name, modules_list->modules[modules_iter].name) != 0)
        modules_iter++;

    if (modules_list->modules[modules_iter].name) {
        *module_found = &(modules_list->modules[modules_iter]);
        dprintf("CLI DEBUG: module %s found\n", (*module_found)->name);
        return;
    }

not_found:
    *module_found = NULL;
    return;
}

/**
 * autocomplete_command - print matching commands
 * @command:    Beginning of the command
 *
 * Given a string @command, print all availables commands starting with
 * @command. Commands are found within the list of commands for the current
 * mode and the hdt mode (if the current mode is not hdt).
 **/
static void autocomplete_command(char *command)
{
    int j = 0;
    struct cli_callback_descr *associated_module = NULL;

    /* First take care of the two special commands: 'show' and 'set' */
    if (strncmp(CLI_SHOW, command, strlen(command)) == 0) {
        printf("%s\n", CLI_SHOW);
        autocomplete_add_token_to_list(CLI_SHOW);
    }
    if (strncmp(CLI_SET, command, strlen(command)) == 0) {
        printf("%s\n", CLI_SET);
        autocomplete_add_token_to_list(CLI_SET);
    }

    /*
     * Then, go through the modes for the special case
     *      '<mode>' -> 'set mode <mode>'
     */
    while (list_modes[j]) {
        if (strncmp(list_modes[j]->name, command, strlen(command)) == 0) {
            printf("%s\n", list_modes[j]->name);
            autocomplete_add_token_to_list(list_modes[j]->name);
        }
        j++;
    }

    /*
     * Let's go now through the list of default_modules for the current mode
     * (single token commands for the current_mode)
     */
    j = 0;
    if (current_mode->default_modules && current_mode->default_modules->modules) {
        while (current_mode->default_modules->modules[j].name) {
            if (strncmp(current_mode->default_modules->modules[j].name,
                        command, strlen(command)) == 0) {
                printf("%s\n", current_mode->default_modules->modules[j].name);
                autocomplete_add_token_to_list(current_mode->default_modules->
                                               modules[j].name);
            }
            j++;
        }
    }

    /*
     * Finally, if the current_mode is not hdt, list the available
     * default_modules of hdt (these are always available from any mode).
     */
    if (current_mode->mode == HDT_MODE)
        return;

    if (!hdt_mode.default_modules || !hdt_mode.default_modules->modules)
        return;

    j = 0;
    while (hdt_mode.default_modules &&
           hdt_mode.default_modules->modules[j].name) {
        /*
         * Any default command that is present in hdt mode but
         * not in the current mode is available. A default
         * command can be redefined in the current mode though.
         * This next call tests this use case: if it is
         * overwritten, do not print it again.
         */
        find_cli_callback_descr(hdt_mode.default_modules->modules[j].name,
                                current_mode->default_modules,
                                &associated_module);
        if (associated_module == NULL &&
            strncmp(command,
                    hdt_mode.default_modules->modules[j].name,
                    strlen(command)) == 0) {
            printf("%s\n", hdt_mode.default_modules->modules[j].name);
            autocomplete_add_token_to_list(hdt_mode.default_modules->modules[j].
                                           name);
        }
        j++;
    }
}

/**
 * autocomplete_module - print matching modules
 * @command:    Command on the command line (not NULL)
 * @module:     Beginning of the module
 *
 * Given a command @command and a string @module, print all availables modules
 * starting with @module for command @command. Commands are found within the
 * list of commands for the current mode and the hdt mode (if the current mode
 * is not hdt).
 **/
static void autocomplete_module(char *command, char *module)
{
    int j = 0;
    char autocomplete_full_line[MAX_LINE_SIZE];

    if (strncmp(CLI_SHOW, command, strlen(command)) == 0) {
        if (!current_mode->show_modules || !current_mode->show_modules->modules)
            return;

        while (current_mode->show_modules->modules[j].name) {
            if (strncmp(current_mode->show_modules->modules[j].name,
                        module, strlen(module)) == 0) {
                printf("%s\n", current_mode->show_modules->modules[j].name);
                sprintf(autocomplete_full_line, "%s %s",
                        CLI_SHOW, current_mode->show_modules->modules[j].name);
                autocomplete_add_token_to_list(autocomplete_full_line);
            }
            j++;
        }
    } else if (strncmp(CLI_SET, command, strlen(command)) == 0) {
        j = 0;
        if (!current_mode->set_modules || !current_mode->set_modules->modules)
            return;

        while (current_mode->set_modules->modules[j].name) {
            if (strncmp(current_mode->set_modules->modules[j].name,
                        module, strlen(module)) == 0) {
                printf("%s\n", current_mode->set_modules->modules[j].name);
                sprintf(autocomplete_full_line, "%s %s",
                        CLI_SET, current_mode->set_modules->modules[j].name);
                autocomplete_add_token_to_list(autocomplete_full_line);
            }
            j++;
        }
    }
}

/**
 * autocomplete - find possible matches for a command line
 * @line:       command line to parse
 **/
static void autocomplete(char *line)
{
    int i;
    int argc = 0;
    char *command = NULL, *module = NULL;
    char **argv = NULL;

    parse_command_line(line, &command, &module, &argc, argv);

    dprintf("CLI DEBUG autocomplete: before checking args\n");
    /* If the user specified arguments, there is nothing we can complete */
    if (argc != 0)
        goto out;

    /* No argument, (the start of) a module has been specified */
    if (module != NULL) {
        autocomplete_module(command, module);
        free(module);
        goto out;
    }

    /* No argument, no module, (the start of) a command has been specified */
    if (command != NULL) {
        autocomplete_command(command);
        free(command);
        goto out;
    }

out:
    /* Let's not forget to clean ourselves */
    for (i = 0; i < argc; i++)
        free(argv[i]);
    if (argc > 0)
        free(argv);
    return;
}

/**
 * exec_command - main logic to map the command line to callbacks
 **/
static void exec_command(char *line, struct s_hardware *hardware)
{
    int argc, i = 0;
    char *command = NULL, *module = NULL;
    char **argv = NULL;
    struct cli_callback_descr *current_module = NULL;

    /* This will allocate memory for command and module */
    parse_command_line(line, &command, &module, &argc, argv);

    dprintf("CLI DEBUG exec: Checking for aliases\n");
    /*
     * Expand shortcuts, if needed
     * This will allocate memory for argc/argv
     */
    expand_aliases(line, &command, &module, &argc, argv);
    
    find_cli_callback_descr(command, current_mode->default_modules,
                                &current_module);

    if ((module == NULL) || (current_module->nomodule == true)) {
        dprintf("CLI DEBUG exec : single command detected\n");
        /*
         * A single word was specified: look at the list of default
         * commands in the current mode to see if there is a match.
         * If not, it may be a generic function (exit, help, ...). These
         * are stored in the list of default commands of the hdt mode.
         */

        /* First of all it the command doesn't need module, let's rework the arguments */
        if ((current_module->nomodule == true) && ( module != NULL)) {
                dprintf("CLI_DEBUG exec: Reworking arguments with argc=%d\n",argc);
                char **new_argv=NULL;
                new_argv=malloc((argc + 2)*sizeof(char *));
                for (int argc_iter=0; argc_iter<argc; argc_iter++) {
                        dprintf("CLI_DEBUG exec rework : copy %d to %d (%s)\n",argc_iter,argc_iter+1,argv[argc_iter]);
                        new_argv[argc_iter+1] = malloc(strlen(argv[argc_iter]));
                        strlcpy(new_argv[argc_iter+1], argv[argc_iter], strlen(argv[argc_iter]));
                        free(argv[argc_iter]);
                }
                new_argv[0] = malloc(strlen(module)*sizeof(char));
                strlcpy(new_argv[0], module, strlen(module));
                argc++;
                free(argv);
                argv=new_argv;
        }

        if (current_module != NULL)
            current_module->exec(argc, argv, hardware);
        else if (!strncmp(command, CLI_SHOW, sizeof(CLI_SHOW) - 1) &&
                 current_mode->show_modules != NULL &&
                 current_mode->show_modules->default_callback != NULL)
            current_mode->show_modules->default_callback(argc, argv, hardware);
        else if (!strncmp(command, CLI_SET, sizeof(CLI_SET) - 1) &&
                 current_mode->set_modules != NULL &&
                 current_mode->set_modules->default_callback != NULL)
            current_mode->set_modules->default_callback(argc, argv, hardware);
        else {
            find_cli_callback_descr(command, hdt_mode.default_modules,
                                    &current_module);
            if (current_module != NULL)
                current_module->exec(argc, argv, hardware);
            else
                more_printf("unknown command: '%s'\n", command);
        }
    } else {
        /*
         * A module has been specified! We now need to find the type of command.
         *
         * The syntax of the cli is the following:
         *    <type of command> <module on which to operate> <args>
         * e.g.
         *    dmi> show system
         *    dmi> show bank 1
         *    dmi> show memory 0 1
         *    pci> show device 12
         *    hdt> set mode dmi
         */
        if (!strncmp(command, CLI_SHOW, sizeof(CLI_SHOW) - 1)) {
            dprintf("CLI DEBUG exec: %s command detected\n", CLI_SHOW);
            /* Look first for a 'show' callback in the current mode */
            find_cli_callback_descr(module, current_mode->show_modules,
                                    &current_module);
            /* Execute the callback, if found */
            if (current_module != NULL)
                current_module->exec(argc, argv, hardware);
            else {
                dprintf("CLI DEBUG exec: Looking for callback\n");
                /* Look now for a 'show' callback in the hdt mode */
                find_cli_callback_descr(module, hdt_mode.show_modules,
                                        &current_module);
                /* Execute the callback, if found */
                if (current_module != NULL)
                    current_module->exec(argc, argv, hardware);
                else
                    printf("unknown module: '%s'\n", module);
            }
        } else if (!strncmp(command, CLI_SET, sizeof(CLI_SET) - 1)) {
            dprintf("CLI DEBUG exec : %s command detected\n", CLI_SET);
            /* Look now for a 'set' callback in the hdt mode */
            find_cli_callback_descr(module, current_mode->set_modules,
                                    &current_module);
            /* Execute the callback, if found */
            if (current_module != NULL)
                current_module->exec(argc, argv, hardware);
            else {
                /* Look now for a 'set' callback in the hdt mode */
                find_cli_callback_descr(module, hdt_mode.set_modules,
                                        &current_module);
                /* Execute the callback, if found */
                if (current_module != NULL)
                    current_module->exec(argc, argv, hardware);
                else
                    printf("unknown module: '%s'\n", module);
            }
        }
    }

    /* Let's not forget to clean ourselves */
    if (command != NULL)
        free(command);
    if (module != NULL)
        free(module);
    for (i = 0; i < argc; i++)
        free(argv[i]);
    if (argc > 0)
        free(argv);
}

static void reset_prompt(void)
{
    /* No need to display the prompt if we exit */
    if (hdt_cli.mode != EXIT_MODE) {
        printf("%s", hdt_cli.prompt);
        /* Reset the line */
        hdt_cli.cursor_pos = 0;
    }
}

void start_auto_mode(struct s_hardware *hardware)
{
    char *mypch;
    int nb_commands = 0;
    char *commands[MAX_NB_AUTO_COMMANDS];

    more_printf("\nEntering Auto mode\n");

    /* Protecting the auto_label from the strtok modifications */
    char *temp = strdup(hardware->auto_label);

    /* Searching & saving all commands */
    mypch = strtok(temp, AUTO_SEPARATOR);
    while (mypch != NULL) {
        if ((strlen(remove_spaces(mypch)) > 0) &&
            (remove_spaces(mypch)[0] != AUTO_SEPARATOR[0])) {
            nb_commands++;
            if ((commands[nb_commands] = malloc(AUTO_COMMAND_SIZE)) != NULL) {
                sprintf(commands[nb_commands], "%s", remove_spaces(mypch));
            } else
                nb_commands--;
        }
        mypch = strtok(NULL, AUTO_SEPARATOR);
    }

    free(temp);

    /* Executing found commands */
    for (int i = 1; i <= nb_commands; i++) {
        if (commands[i]) {
            if (!quiet)
                more_printf("%s%s\n", hdt_cli.prompt, commands[i]);
            exec_command(commands[i], hardware);
            free(commands[i]);
        }
    }

    if (!quiet)
        more_printf("\nExiting Auto mode\n");

    more_printf("\n");
}

void print_history(int argc, char **argv, struct s_hardware * hardware)
{
    (void)argc;
    (void)argv;
    (void)hardware;

    reset_more_printf();
    for (int i = 1; i <= MAX_HISTORY_SIZE; i++) {
        if (i == hdt_cli.history_pos) {
            more_printf("*%d:'%s'\n", i, hdt_cli.history[i]);
            continue;
        }
        if (strlen(hdt_cli.history[i]) == 0)
            continue;
        more_printf(" %d:'%s'\n", i, hdt_cli.history[i]);
    }
}

/* Code that manages the cli mode */
void start_cli_mode(struct s_hardware *hardware)
{
    int current_key = 0;
    int future_history_pos = 1; /* position of the next position in the history */
    int current_future_history_pos = 1; /* Temp variable */
    bool display_history = true;        /* Temp Variable */
    char temp_command[MAX_LINE_SIZE];

    hdt_cli.cursor_pos = 0;
    memset(hdt_cli.history, 0, sizeof(hdt_cli.history));
    hdt_cli.history_pos = 1;
    hdt_cli.max_history_pos = 1;

    /* Find the mode selected */
    set_mode(HDT_MODE, hardware);
    find_cli_mode_descr(hdt_cli.mode, &current_mode);
    if (current_mode == NULL) {
        /* Shouldn't get here... */
        more_printf("!!! BUG: Mode '%d' unknown.\n", hdt_cli.mode);
        return;
    }

    /* Start the auto mode if the command line is set */
    if (strlen(hardware->auto_label) > 0) {
        start_auto_mode(hardware);
    }

    more_printf("Entering CLI mode\n");

    reset_prompt();

    while (hdt_cli.mode != EXIT_MODE) {

        /* Display the cursor */
        display_cursor(true);

        /* Let's put the cursor blinking until we get an input */
        set_cursor_blink(true);

        /* We wait endlessly for a keyboard input */
        current_key = get_key(stdin, 0);

        /* We have to cancel the blinking mode to prevent
         * input text to blink */
        set_cursor_blink(false);

        /* Reset autocomplete buffer unless TAB is pressed */
        if (current_key != KEY_TAB)
            autocomplete_destroy_list();

        switch (current_key) {
            /* clear until then end of line */
        case KEY_CTRL('k'):
            /* Clear the end of the line */
            clear_end_of_line();
            memset(&INPUT[hdt_cli.cursor_pos], 0,
                   strlen(INPUT) - hdt_cli.cursor_pos);
            break;

        case KEY_CTRL('c'):
            printf("\n");
            reset_prompt();
            break;

        case KEY_LEFT:
            if (hdt_cli.cursor_pos > 0) {
                move_cursor_left(1);
                hdt_cli.cursor_pos--;
            }
            break;

        case KEY_RIGHT:
            if (hdt_cli.cursor_pos < (int)strlen(INPUT)) {
                move_cursor_right(1);
                hdt_cli.cursor_pos++;
            }
            break;

        case KEY_CTRL('e'):
        case KEY_END:
            /* Calling with a 0 value will make the cursor move */
            /* So, let's move the cursor only if needed */
            if ((strlen(INPUT) - hdt_cli.cursor_pos) > 0) {
                /* Return to the begining of line */
                move_cursor_right(strlen(INPUT) - hdt_cli.cursor_pos);
                hdt_cli.cursor_pos = strlen(INPUT);
            }
            break;

        case KEY_CTRL('a'):
        case KEY_HOME:
            /* Calling with a 0 value will make the cursor move */
            /* So, let's move the cursor only if needed */
            if (hdt_cli.cursor_pos > 0) {
                /* Return to the begining of line */
                move_cursor_left(hdt_cli.cursor_pos);
                hdt_cli.cursor_pos = 0;
            }
            break;

        case KEY_UP:

            /* Saving future position */
            current_future_history_pos = future_history_pos;

            /* We have to compute the next position */
            if (future_history_pos == 1) {
                future_history_pos = MAX_HISTORY_SIZE;
            } else {
                future_history_pos--;
            }

            /* Does the next position is valid */
            if (strlen(hdt_cli.history[future_history_pos]) == 0) {
                /* Position is invalid, restoring position */
                future_history_pos = current_future_history_pos;
                break;
            }

            /* Let's make that future position the one we use */
            memset(INPUT, 0, sizeof(INPUT));
            strlcpy(INPUT, hdt_cli.history[future_history_pos], sizeof(INPUT));

            /* Clear the line */
            clear_line();

            /* Move to the begining of line */
            move_cursor_to_column(0);

            reset_prompt();
            printf("%s", INPUT);
            hdt_cli.cursor_pos = strlen(INPUT);
            break;

        case KEY_DOWN:
            display_history = true;

            /* Saving future position */
            current_future_history_pos = future_history_pos;

            if (future_history_pos == MAX_HISTORY_SIZE) {
                future_history_pos = 1;
            } else {
                future_history_pos++;
            }

            /* Does the next position is valid */
            if (strlen(hdt_cli.history[future_history_pos]) == 0)
                display_history = false;

            /* An exception is made to reach the last empty line */
            if (future_history_pos == hdt_cli.max_history_pos)
                display_history = true;

            if (display_history == false) {
                /* Position is invalid, restoring position */
                future_history_pos = current_future_history_pos;
                break;
            }

            /* Let's make that future position the one we use */
            memset(INPUT, 0, sizeof(INPUT));
            strlcpy(INPUT, hdt_cli.history[future_history_pos], sizeof(INPUT));

            /* Clear the line */
            clear_line();

            /* Move to the begining of line */
            move_cursor_to_column(0);

            reset_prompt();
            printf("%s", INPUT);
            hdt_cli.cursor_pos = strlen(INPUT);
            break;

        case KEY_TAB:
            if (autocomplete_backlog) {
                clear_line();
                /* Move to the begining of line */
                move_cursor_to_column(0);
                reset_prompt();
                printf("%s", autocomplete_last_seen->autocomplete_token);
                strlcpy(INPUT,
                        autocomplete_last_seen->autocomplete_token,
                        sizeof(INPUT));
                hdt_cli.cursor_pos = strlen(INPUT);

                /* Cycle through the list */
                autocomplete_last_seen = autocomplete_last_seen->next;
                if (autocomplete_last_seen == NULL)
                    autocomplete_last_seen = autocomplete_head;
            } else {
                printf("\n");
                autocomplete(skip_spaces(INPUT));
                autocomplete_last_seen = autocomplete_head;

                printf("%s%s", hdt_cli.prompt, INPUT);
            }
            break;

        case KEY_ENTER:
            printf("\n");
            if (strlen(remove_spaces(INPUT)) < 1) {
                reset_prompt();
                break;
            }
            exec_command(remove_spaces(INPUT), hardware);
            hdt_cli.history_pos++;

            /* Did we reach the end of the history ?*/
            if (hdt_cli.history_pos > MAX_HISTORY_SIZE) {
                /* Let's return at the beginning */    
                hdt_cli.history_pos = 1;
            }

            /* Does the next position is already used ?
             * If yes, we are cycling in history */
            if (strlen(INPUT) > 0) {
                /* Let's clean that entry */
                memset(&INPUT,0,sizeof(INPUT));
            }

            future_history_pos = hdt_cli.history_pos;
            if (hdt_cli.history_pos > hdt_cli.max_history_pos)
                hdt_cli.max_history_pos = hdt_cli.history_pos;
            reset_prompt();
            break;

        case KEY_CTRL('d'):
        case KEY_DELETE:
            /* No need to delete when input is empty */
            if (strlen(INPUT) == 0)
                break;
            /* Don't delete when cursor is at the end of the line */
            if (hdt_cli.cursor_pos >= strlen(INPUT))
                break;

            for (int c = hdt_cli.cursor_pos; c < (int)strlen(INPUT) - 1; c++)
                INPUT[c] = INPUT[c + 1];
            INPUT[strlen(INPUT) - 1] = '\0';

            /* Clear the end of the line */
            clear_end_of_line();

            /* Print the resulting buffer */
            printf("%s", INPUT + hdt_cli.cursor_pos);

            /* Replace the cursor at the proper place */
            if (strlen(INPUT + hdt_cli.cursor_pos) > 0)
                move_cursor_left(strlen(INPUT + hdt_cli.cursor_pos));
            break;

        case KEY_DEL:
        case KEY_BACKSPACE:
            /* Don't delete prompt */
            if (hdt_cli.cursor_pos == 0)
                break;

            for (int c = hdt_cli.cursor_pos - 1;
                 c < (int)strlen(INPUT) - 1; c++)
                INPUT[c] = INPUT[c + 1];
            INPUT[strlen(INPUT) - 1] = '\0';

            /* Get one char back */
            move_cursor_left(1);

            /* Clear the end of the line */
            clear_end_of_line();

            /* Print the resulting buffer */
            printf("%s", INPUT + hdt_cli.cursor_pos - 1);

            /* Realing to a char before the place we were */
            hdt_cli.cursor_pos--;
            move_cursor_to_column(strlen(hdt_cli.prompt) + hdt_cli.cursor_pos +
                                  1);

            break;

        case KEY_F1:
            printf("\n");
            exec_command(CLI_HELP, hardware);
            reset_prompt();
            break;

        default:
            if ((current_key < 0x20) || (current_key > 0x7e))
                break;
            /* Prevent overflow */
            if (hdt_cli.cursor_pos > MAX_LINE_SIZE - 2)
                break;
            /* If we aren't at the end of the input line, let's insert */
            if (hdt_cli.cursor_pos < (int)strlen(INPUT)) {
                char key[2];
                int trailing_chars = strlen(INPUT) - hdt_cli.cursor_pos;
                memset(temp_command, 0, sizeof(temp_command));
                strlcpy(temp_command, INPUT, hdt_cli.cursor_pos);
                sprintf(key, "%c", current_key);
                strncat(temp_command, key, 1);
                strncat(temp_command,
                        INPUT + hdt_cli.cursor_pos, trailing_chars);
                memset(INPUT, 0, sizeof(INPUT));
                snprintf(INPUT, sizeof(INPUT), "%s", temp_command);

                /* Clear the end of the line */
                clear_end_of_line();

                /* Print the resulting buffer */
                printf("%s", INPUT + hdt_cli.cursor_pos);

                /* Return where we must put the new char */
                move_cursor_left(trailing_chars);

            } else {
                putchar(current_key);
                INPUT[hdt_cli.cursor_pos] = current_key;
            }
            hdt_cli.cursor_pos++;
            break;
        }
    }
}