src/lib/cmdline_parse_string.c

   1 /*-
   2  * Copyright (c) <2010>, Intel Corporation
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  *
  12  * - Redistributions in binary form must reproduce the above copyright
  13  *   notice, this list of conditions and the following disclaimer in
  14  *   the documentation and/or other materials provided with the
  15  *   distribution.
  16  *
  17  * - Neither the name of Intel Corporation nor the names of its
  18  *   contributors may be used to endorse or promote products derived
  19  *   from this software without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  25  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  27  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  28  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  30  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  31  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  32  * OF THE POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 /*
  36  * Copyright (c) 2009, Olivier MATZ <zer0@droids-corp.org>
  37  * All rights reserved.
  38  * Redistribution and use in source and binary forms, with or without
  39  * modification, are permitted provided that the following conditions are met:
  40  *
  41  *     * Redistributions of source code must retain the above copyright
  42  *       notice, this list of conditions and the following disclaimer.
  43  *     * Redistributions in binary form must reproduce the above copyright
  44  *       notice, this list of conditions and the following disclaimer in the
  45  *       documentation and/or other materials provided with the distribution.
  46  *     * Neither the name of the University of California, Berkeley nor the
  47  *       names of its contributors may be used to endorse or promote products
  48  *       derived from this software without specific prior written permission.
  49  *
  50  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
  51  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  52  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  53  * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
  54  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  55  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  56  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  57  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  58  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  59  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  60  */
  61
  62 #include <stdio.h>
  63 #include <inttypes.h>
  64 #include <ctype.h>
  65 #include <string.h>
  66
  67 #include "cmdline_parse.h"
  68 #include "cmdline_parse_string.h"
  69
  70 struct cmdline_token_ops cmdline_token_string_ops = {
  71         .parse = cmdline_parse_string,
  72         .complete_get_nb = cmdline_complete_get_nb_string,
  73         .complete_get_elt = cmdline_complete_get_elt_string,
  74         .get_help = cmdline_get_help_string,
  75 };
  76
  77 #define MULTISTRING_HELP "Mul-choice STRING"
  78 #define ANYSTRING_HELP   "Any STRING"
  79 #define FIXEDSTRING_HELP "Fixed STRING"
  80
  81 static unsigned int
  82 get_token_len(const char *s)
  83 {
  84         char c;
  85         unsigned int i=0;
  86
  87         c = s[i];
  88         while (c!='#' && c!='\0') {
  89                 i++;
  90                 c = s[i];
  91         }
  92         return i;
  93 }
  94
  95 static const char *
  96 get_next_token(const char *s)
  97 {
  98         unsigned int i;
  99         i = get_token_len(s);
 100         if (s[i] == '#')
 101                 return s+i+1;
 102         return NULL;
 103 }
 104
 105 int
 106 cmdline_parse_string(cmdline_parse_token_hdr_t *tk, const char *buf, void *res)
 107 {
 108         struct cmdline_token_string *tk2 = (struct cmdline_token_string *)tk;
 109         struct cmdline_token_string_data *sd = &tk2->string_data;;
 110         unsigned int token_len;
 111         const char *str;
 112
 113         if (! *buf)
 114                 return -1;
 115
 116         /* fixed string */
 117         if (sd->str) {
 118                 str = sd->str;
 119                 do {
 120                         token_len = get_token_len(str);
 121
 122                         /* if token is too big... */
 123                         if (token_len >= STR_TOKEN_SIZE - 1) {
 124                                 continue;
 125                         }
 126
 127                         if ( strncmp(buf, str, token_len) ) {
 128                                 continue;
 129                         }
 130
 131                         if ( !cmdline_isendoftoken(*(buf+token_len)) ) {
 132                                 continue;
 133                         }
 134
 135                         break;
 136                 } while ( (str = get_next_token(str)) != NULL );
 137
 138                 if (!str)
 139                         return -1;
 140         }
 141         /* unspecified string */
 142         else {
 143                 token_len=0;
 144                 while(!cmdline_isendoftoken(buf[token_len]) &&
 145                       token_len < (STR_TOKEN_SIZE-1))
 146                         token_len++;
 147
 148                 /* return if token too long */
 149                 if (token_len >= STR_TOKEN_SIZE - 1) {
 150                         return -1;
 151                 }
 152         }
 153
 154         if (res) {
 155                 /* we are sure that token_len is < STR_TOKEN_SIZE-1 */
 156                 strncpy(res, buf, token_len);
 157                 *((char *)res + token_len) = 0;
 158         }
 159
 160         return token_len;
 161 }
 162
 163 int cmdline_complete_get_nb_string(cmdline_parse_token_hdr_t *tk)
 164 {
 165         struct cmdline_token_string *tk2 = (struct cmdline_token_string *)tk;
 166         struct cmdline_token_string_data *sd = &tk2->string_data;;
 167         int ret=1;
 168         const char *str;
 169
 170         if (!sd->str)
 171                 return 0;
 172
 173         str = sd->str;
 174         while( (str = get_next_token(str)) != NULL ) {
 175                 ret++;
 176         }
 177         return ret;
 178 }
 179
 180 int cmdline_complete_get_elt_string(cmdline_parse_token_hdr_t *tk, int idx,
 181                                     char *dstbuf, unsigned int size)
 182 {
 183         struct cmdline_token_string *tk2 = (struct cmdline_token_string *)tk;
 184         struct cmdline_token_string_data *sd = &tk2->string_data;;
 185         const char *s;
 186         unsigned int len;
 187
 188         s = sd->str;
 189
 190         while (idx-- && s)
 191                 s = get_next_token(s);
 192
 193         if (!s)
 194                 return -1;
 195
 196         len = get_token_len(s);
 197         if (len > size - 1)
 198                 return -1;
 199
 200         memcpy(dstbuf, s, len);
 201         dstbuf[len] = '\0';
 202         return 0;
 203 }
 204
 205
 206 int cmdline_get_help_string(cmdline_parse_token_hdr_t *tk, char *dstbuf,
 207                             unsigned int size)
 208 {
 209         struct cmdline_token_string *tk2 = (struct cmdline_token_string *)tk;
 210         struct cmdline_token_string_data *sd = &tk2->string_data;;
 211         const char *s;
 212
 213         s = sd->str;
 214
 215         if (s) {
 216                 if (get_next_token(s)) {
 217                         strncpy(dstbuf, MULTISTRING_HELP, size);
 218                 }
 219                 else {
 220                         strncpy(dstbuf, FIXEDSTRING_HELP, size);
 221                 }
 222         }
 223         else {
 224                 strncpy(dstbuf, ANYSTRING_HELP, size);
 225         }
 226
 227         dstbuf[size-1] = '\0';
 228
 229         return 0;
 230 }