/*

    mtr  --  a network diagnostic tool

    Copyright (C) 2016  Matt Kimball

    This program is free software; you can redistribute it and/or modify

    it under the terms of the GNU General Public License version 2 as

    published by the Free Software Foundation.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program; if not, write to the Free Software

    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#include "cmdparse.h"

#include <ctype.h>

#include <errno.h>

#include <stdlib.h>

#include <string.h>

/*

    NUL terminate the whitespace separated tokens in the command string.

    This modifies command_string in-place with NUL characters.

    Fill the tokens array with pointers to the tokens, and return the

    number of tokens found.

*/

static

int tokenize_command(

    char **tokens,

    int max_tokens,

    char *command_string)

{

    int token_count = 0;

    int on_space = 1;

    int i;

    for (i = 0; command_string[i]; i++) {

        if (on_space) {

            if (!isspace((unsigned char) command_string[i])) {

                /*  Take care not to exceed the token array length  */

                if (token_count >= max_tokens) {

                    return -1;

                }

                tokens[token_count++] = &command_string[i];

                on_space = 0;

            }

        } else {

            if (isspace((unsigned char) command_string[i])) {

                command_string[i] = 0;

                on_space = 1;

            }

        }

    }

    return token_count;

}

/*

    Parse a command string (or command reply string) into a command_t

    structure for later semantic interpretation.  Returns EINVAL if the

    command string is unparseable or zero for success.

    comamnd_string will be modified in-place with NUL characters terminating

    tokens, and the command_t will use pointers to the conents of

    command_string without copying, so any interpretation of the

    command_t structure requires that the command_string memory has not yet

    been freed or otherwise reused.

*/

int parse_command(

    struct command_t *command,

    char *command_string)

{

    char *tokens[MAX_COMMAND_TOKENS];

    int token_count;

    int i;

    memset(command, 0, sizeof(struct command_t));

    /*  Tokenize the string using whitespace  */

    token_count =

        tokenize_command(tokens, MAX_COMMAND_TOKENS, command_string);

    if (token_count < 2) {

        errno = EINVAL;

        return -1;

    }

    /*  Expect the command token to be a numerical value  */

    errno = 0;

    command->token = strtol(tokens[0], NULL, 10);

    if (errno) {

        errno = EINVAL;

        return -1;

    }

    command->command_name = tokens[1];

    /*

       The tokens beyond the command name are expected to be in

       name, value pairs.

     */

    i = 2;

    command->argument_count = 0;

    while (i < token_count) {

        /*  It's an error if we get a name without a key  */

        if (i + 1 >= token_count) {

            errno = EINVAL;

            return -1;

        }

        /*  It's an error if we get more arguments than we have space for  */

        if (command->argument_count >= MAX_COMMAND_ARGUMENTS) {

            errno = EINVAL;

            return -1;

        }

        command->argument_name[command->argument_count] = tokens[i];

        command->argument_value[command->argument_count] = tokens[i + 1];

        command->argument_count++;

        i += 2;

    }

    return 0;

}