Return to cmdparse.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mtr / packet

mtr 0.94

    1: /*
    2:     mtr  --  a network diagnostic tool
    3:     Copyright (C) 2016  Matt Kimball
    4: 
    5:     This program is free software; you can redistribute it and/or modify
    6:     it under the terms of the GNU General Public License version 2 as
    7:     published by the Free Software Foundation.
    8: 
    9:     This program is distributed in the hope that it will be useful,
   10:     but WITHOUT ANY WARRANTY; without even the implied warranty of
   11:     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   12:     GNU General Public License for more details.
   13: 
   14:     You should have received a copy of the GNU General Public License along
   15:     with this program; if not, write to the Free Software Foundation, Inc.,
   16:     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
   17: */
   18: 
   19: #include "cmdparse.h"
   20: 
   21: #include <ctype.h>
   22: #include <errno.h>
   23: #include <stdlib.h>
   24: #include <string.h>
   25: 
   26: /*
   27:     NUL terminate the whitespace separated tokens in the command string.
   28:     This modifies command_string in-place with NUL characters.
   29:     Fill the tokens array with pointers to the tokens, and return the
   30:     number of tokens found.
   31: */
   32: static
   33: int tokenize_command(
   34:     char **tokens,
   35:     int max_tokens,
   36:     char *command_string)
   37: {
   38:     int token_count = 0;
   39:     int on_space = 1;
   40:     int i;
   41: 
   42:     for (i = 0; command_string[i]; i++) {
   43:         if (on_space) {
   44:             if (!isspace((unsigned char) command_string[i])) {
   45:                 /*  Take care not to exceed the token array length  */
   46:                 if (token_count >= max_tokens) {
   47:                     return -1;
   48:                 }
   49: 
   50:                 tokens[token_count++] = &command_string[i];
   51:                 on_space = 0;
   52:             }
   53:         } else {
   54:             if (isspace((unsigned char) command_string[i])) {
   55:                 command_string[i] = 0;
   56:                 on_space = 1;
   57:             }
   58:         }
   59:     }
   60: 
   61:     return token_count;
   62: }
   63: 
   64: /*
   65:     Parse a command string (or command reply string) into a command_t
   66:     structure for later semantic interpretation.  Returns EINVAL if the
   67:     command string is unparseable or zero for success.
   68: 
   69:     command_string will be modified in-place with NUL characters terminating
   70:     tokens, and the command_t will use pointers to the contents of
   71:     command_string without copying, so any interpretation of the
   72:     command_t structure requires that the command_string memory has not yet
   73:     been freed or otherwise reused.
   74: */
   75: int parse_command(
   76:     struct command_t *command,
   77:     char *command_string)
   78: {
   79:     char *tokens[MAX_COMMAND_TOKENS];
   80:     int token_count;
   81:     int i;
   82: 
   83:     memset(command, 0, sizeof(struct command_t));
   84: 
   85:     /*  Tokenize the string using whitespace  */
   86:     token_count =
   87:         tokenize_command(tokens, MAX_COMMAND_TOKENS, command_string);
   88:     if (token_count < 2) {
   89:         errno = EINVAL;
   90:         return -1;
   91:     }
   92: 
   93:     /*  Expect the command token to be a numerical value  */
   94:     errno = 0;
   95:     command->token = strtol(tokens[0], NULL, 10);
   96:     if (errno) {
   97:         errno = EINVAL;
   98:         return -1;
   99:     }
  100:     command->command_name = tokens[1];
  101: 
  102:     /*
  103:        The tokens beyond the command name are expected to be in
  104:        name, value pairs.
  105:      */
  106:     i = 2;
  107:     command->argument_count = 0;
  108:     while (i < token_count) {
  109:         /*  It's an error if we get a name without a key  */
  110:         if (i + 1 >= token_count) {
  111:             errno = EINVAL;
  112:             return -1;
  113:         }
  114: 
  115:         /*  It's an error if we get more arguments than we have space for  */
  116:         if (command->argument_count >= MAX_COMMAND_ARGUMENTS) {
  117:             errno = EINVAL;
  118:             return -1;
  119:         }
  120: 
  121:         command->argument_name[command->argument_count] = tokens[i];
  122:         command->argument_value[command->argument_count] = tokens[i + 1];
  123:         command->argument_count++;
  124: 
  125:         i += 2;
  126:     }
  127: 
  128:     return 0;
  129: }