lib/librte_cmdline/cmdline_parse.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation.
   3  * Copyright (c) 2009, Olivier MATZ <zer0@droids-corp.org>
   4  * All rights reserved.
   5  */
   6
   7 #include <stdio.h>
   8 #include <stdarg.h>
   9 #include <errno.h>
  10 #include <string.h>
  11 #include <inttypes.h>
  12 #include <ctype.h>
  13
  14 #include <netinet/in.h>
  15
  16 #include <rte_string_fns.h>
  17
  18 #include "cmdline_private.h"
  19
  20 #ifdef RTE_LIBRTE_CMDLINE_DEBUG
  21 #define debug_printf printf
  22 #else
  23 #define debug_printf(args...) do {} while(0)
  24 #endif
  25
  26 #define CMDLINE_BUFFER_SIZE 64
  27
  28 /* isblank() needs _XOPEN_SOURCE >= 600 || _ISOC99_SOURCE, so use our
  29  * own. */
  30 static int
  31 isblank2(char c)
  32 {
  33         if (c == ' ' ||
  34             c == '\t' )
  35                 return 1;
  36         return 0;
  37 }
  38
  39 static int
  40 isendofline(char c)
  41 {
  42         if (c == '\n' ||
  43             c == '\r' )
  44                 return 1;
  45         return 0;
  46 }
  47
  48 static int
  49 iscomment(char c)
  50 {
  51         if (c == '#')
  52                 return 1;
  53         return 0;
  54 }
  55
  56 int
  57 cmdline_isendoftoken(char c)
  58 {
  59         if (!c || iscomment(c) || isblank2(c) || isendofline(c))
  60                 return 1;
  61         return 0;
  62 }
  63
  64 int
  65 cmdline_isendofcommand(char c)
  66 {
  67         if (!c || iscomment(c) || isendofline(c))
  68                 return 1;
  69         return 0;
  70 }
  71
  72 static unsigned int
  73 nb_common_chars(const char * s1, const char * s2)
  74 {
  75         unsigned int i=0;
  76
  77         while (*s1==*s2 && *s1) {
  78                 s1++;
  79                 s2++;
  80                 i++;
  81         }
  82         return i;
  83 }
  84
  85 /** Retrieve either static or dynamic token at a given index. */
  86 static cmdline_parse_token_hdr_t *
  87 get_token(cmdline_parse_inst_t *inst, unsigned int index)
  88 {
  89         cmdline_parse_token_hdr_t *token_p;
  90
  91         /* check presence of static tokens first */
  92         if (inst->tokens[0] || !inst->f)
  93                 return inst->tokens[index];
  94         /* generate dynamic token */
  95         token_p = NULL;
  96         inst->f(&token_p, NULL, &inst->tokens[index]);
  97         return token_p;
  98 }
  99
 100 /**
 101  * try to match the buffer with an instruction (only the first
 102  * nb_match_token tokens if != 0). Return 0 if we match all the
 103  * tokens, else the number of matched tokens, else -1.
 104  */
 105 static int
 106 match_inst(cmdline_parse_inst_t *inst, const char *buf,
 107            unsigned int nb_match_token, void *resbuf, unsigned resbuf_size)
 108 {
 109         cmdline_parse_token_hdr_t *token_p = NULL;
 110         unsigned int i=0;
 111         int n = 0;
 112         struct cmdline_token_hdr token_hdr;
 113
 114         if (resbuf != NULL)
 115                 memset(resbuf, 0, resbuf_size);
 116         /* check if we match all tokens of inst */
 117         while (!nb_match_token || i < nb_match_token) {
 118                 token_p = get_token(inst, i);
 119                 if (!token_p)
 120                         break;
 121                 memcpy(&token_hdr, token_p, sizeof(token_hdr));
 122
 123                 debug_printf("TK\n");
 124                 /* skip spaces */
 125                 while (isblank2(*buf)) {
 126                         buf++;
 127                 }
 128
 129                 /* end of buf */
 130                 if ( isendofline(*buf) || iscomment(*buf) )
 131                         break;
 132
 133                 if (resbuf == NULL) {
 134                         n = token_hdr.ops->parse(token_p, buf, NULL, 0);
 135                 } else {
 136                         unsigned rb_sz;
 137
 138                         if (token_hdr.offset > resbuf_size) {
 139                                 printf("Parse error(%s:%d): Token offset(%u) "
 140                                         "exceeds maximum size(%u)\n",
 141                                         __FILE__, __LINE__,
 142                                         token_hdr.offset, resbuf_size);
 143                                 return -ENOBUFS;
 144                         }
 145                         rb_sz = resbuf_size - token_hdr.offset;
 146
 147                         n = token_hdr.ops->parse(token_p, buf, (char *)resbuf +
 148                                 token_hdr.offset, rb_sz);
 149                 }
 150
 151                 if (n < 0)
 152                         break;
 153
 154                 debug_printf("TK parsed (len=%d)\n", n);
 155                 i++;
 156                 buf += n;
 157         }
 158
 159         /* does not match */
 160         if (i==0)
 161                 return -1;
 162
 163         /* in case we want to match a specific num of token */
 164         if (nb_match_token) {
 165                 if (i == nb_match_token) {
 166                         return 0;
 167                 }
 168                 return i;
 169         }
 170
 171         /* we don't match all the tokens */
 172         if (token_p) {
 173                 return i;
 174         }
 175
 176         /* are there are some tokens more */
 177         while (isblank2(*buf)) {
 178                 buf++;
 179         }
 180
 181         /* end of buf */
 182         if ( isendofline(*buf) || iscomment(*buf) )
 183                 return 0;
 184
 185         /* garbage after inst */
 186         return i;
 187 }
 188
 189
 190 int
 191 cmdline_parse(struct cmdline *cl, const char * buf)
 192 {
 193         unsigned int inst_num=0;
 194         cmdline_parse_inst_t *inst;
 195         const char *curbuf;
 196         union {
 197                 char buf[CMDLINE_PARSE_RESULT_BUFSIZE];
 198                 long double align; /* strong alignment constraint for buf */
 199         } result, tmp_result;
 200         void (*f)(void *, struct cmdline *, void *) = NULL;
 201         void *data = NULL;
 202         int comment = 0;
 203         int linelen = 0;
 204         int parse_it = 0;
 205         int err = CMDLINE_PARSE_NOMATCH;
 206         int tok;
 207         cmdline_parse_ctx_t *ctx;
 208         char *result_buf = result.buf;
 209
 210         if (!cl || !buf)
 211                 return CMDLINE_PARSE_BAD_ARGS;
 212
 213         ctx = cl->ctx;
 214
 215         /*
 216          * - look if the buffer contains at least one line
 217          * - look if line contains only spaces or comments
 218          * - count line length
 219          */
 220         curbuf = buf;
 221         while (! isendofline(*curbuf)) {
 222                 if ( *curbuf == '\0' ) {
 223                         debug_printf("Incomplete buf (len=%d)\n", linelen);
 224                         return 0;
 225                 }
 226                 if ( iscomment(*curbuf) ) {
 227                         comment = 1;
 228                 }
 229                 if ( ! isblank2(*curbuf) && ! comment) {
 230                         parse_it = 1;
 231                 }
 232                 curbuf++;
 233                 linelen++;
 234         }
 235
 236         /* skip all endofline chars */
 237         while (isendofline(buf[linelen])) {
 238                 linelen++;
 239         }
 240
 241         /* empty line */
 242         if ( parse_it == 0 ) {
 243                 debug_printf("Empty line (len=%d)\n", linelen);
 244                 return linelen;
 245         }
 246
 247         debug_printf("Parse line : len=%d, <%.*s>\n",
 248                      linelen, linelen > 64 ? 64 : linelen, buf);
 249
 250         /* parse it !! */
 251         inst = ctx[inst_num];
 252         while (inst) {
 253                 debug_printf("INST %d\n", inst_num);
 254
 255                 /* fully parsed */
 256                 tok = match_inst(inst, buf, 0, result_buf,
 257                                  CMDLINE_PARSE_RESULT_BUFSIZE);
 258
 259                 if (tok > 0) /* we matched at least one token */
 260                         err = CMDLINE_PARSE_BAD_ARGS;
 261
 262                 else if (!tok) {
 263                         debug_printf("INST fully parsed\n");
 264                         /* skip spaces */
 265                         while (isblank2(*curbuf)) {
 266                                 curbuf++;
 267                         }
 268
 269                         /* if end of buf -> there is no garbage after inst */
 270                         if (isendofline(*curbuf) || iscomment(*curbuf)) {
 271                                 if (!f) {
 272                                         memcpy(&f, &inst->f, sizeof(f));
 273                                         memcpy(&data, &inst->data, sizeof(data));
 274                                         result_buf = tmp_result.buf;
 275                                 }
 276                                 else {
 277                                         /* more than 1 inst matches */
 278                                         err = CMDLINE_PARSE_AMBIGUOUS;
 279                                         f=NULL;
 280                                         debug_printf("Ambiguous cmd\n");
 281                                         break;
 282                                 }
 283                         }
 284                 }
 285
 286                 inst_num ++;
 287                 inst = ctx[inst_num];
 288         }
 289
 290         /* call func */
 291         if (f) {
 292                 f(result.buf, cl, data);
 293         }
 294
 295         /* no match */
 296         else {
 297                 debug_printf("No match err=%d\n", err);
 298                 return err;
 299         }
 300
 301         return linelen;
 302 }
 303
 304 int
 305 cmdline_complete(struct cmdline *cl, const char *buf, int *state,
 306                  char *dst, unsigned int size)
 307 {
 308         const char *partial_tok = buf;
 309         unsigned int inst_num = 0;
 310         cmdline_parse_inst_t *inst;
 311         cmdline_parse_token_hdr_t *token_p;
 312         struct cmdline_token_hdr token_hdr;
 313         char tmpbuf[CMDLINE_BUFFER_SIZE], comp_buf[CMDLINE_BUFFER_SIZE];
 314         unsigned int partial_tok_len;
 315         int comp_len = -1;
 316         int tmp_len = -1;
 317         int nb_token = 0;
 318         unsigned int i, n;
 319         int l;
 320         unsigned int nb_completable;
 321         unsigned int nb_non_completable;
 322         int local_state = 0;
 323         const char *help_str;
 324         cmdline_parse_ctx_t *ctx;
 325
 326         if (!cl || !buf || !state || !dst)
 327                 return -1;
 328
 329         ctx = cl->ctx;
 330
 331         debug_printf("%s called\n", __func__);
 332         memset(&token_hdr, 0, sizeof(token_hdr));
 333
 334         /* count the number of complete token to parse */
 335         for (i=0 ; buf[i] ; i++) {
 336                 if (!isblank2(buf[i]) && isblank2(buf[i+1]))
 337                         nb_token++;
 338                 if (isblank2(buf[i]) && !isblank2(buf[i+1]))
 339                         partial_tok = buf+i+1;
 340         }
 341         partial_tok_len = strnlen(partial_tok, RDLINE_BUF_SIZE);
 342
 343         /* first call -> do a first pass */
 344         if (*state <= 0) {
 345                 debug_printf("try complete <%s>\n", buf);
 346                 debug_printf("there is %d complete tokens, <%s> is incomplete\n",
 347                              nb_token, partial_tok);
 348
 349                 nb_completable = 0;
 350                 nb_non_completable = 0;
 351
 352                 inst = ctx[inst_num];
 353                 while (inst) {
 354                         /* parse the first tokens of the inst */
 355                         if (nb_token &&
 356                             match_inst(inst, buf, nb_token, NULL, 0))
 357                                 goto next;
 358
 359                         debug_printf("instruction match\n");
 360                         token_p = get_token(inst, nb_token);
 361                         if (token_p)
 362                                 memcpy(&token_hdr, token_p, sizeof(token_hdr));
 363
 364                         /* non completable */
 365                         if (!token_p ||
 366                             !token_hdr.ops->complete_get_nb ||
 367                             !token_hdr.ops->complete_get_elt ||
 368                             (n = token_hdr.ops->complete_get_nb(token_p)) == 0) {
 369                                 nb_non_completable++;
 370                                 goto next;
 371                         }
 372
 373                         debug_printf("%d choices for this token\n", n);
 374                         for (i=0 ; i<n ; i++) {
 375                                 if (token_hdr.ops->complete_get_elt(token_p, i,
 376                                                                     tmpbuf,
 377                                                                     sizeof(tmpbuf)) < 0)
 378                                         continue;
 379
 380                                 /* we have at least room for one char */
 381                                 tmp_len = strnlen(tmpbuf, sizeof(tmpbuf));
 382                                 if (tmp_len < CMDLINE_BUFFER_SIZE - 1) {
 383                                         tmpbuf[tmp_len] = ' ';
 384                                         tmpbuf[tmp_len+1] = 0;
 385                                 }
 386
 387                                 debug_printf("   choice <%s>\n", tmpbuf);
 388
 389                                 /* does the completion match the
 390                                  * beginning of the word ? */
 391                                 if (!strncmp(partial_tok, tmpbuf,
 392                                              partial_tok_len)) {
 393                                         if (comp_len == -1) {
 394                                                 strlcpy(comp_buf,
 395                                                         tmpbuf + partial_tok_len,
 396                                                         sizeof(comp_buf));
 397                                                 comp_len =
 398                                                         strnlen(tmpbuf + partial_tok_len,
 399                                                                         sizeof(tmpbuf) - partial_tok_len);
 400
 401                                         }
 402                                         else {
 403                                                 comp_len =
 404                                                         nb_common_chars(comp_buf,
 405                                                                         tmpbuf+partial_tok_len);
 406                                                 comp_buf[comp_len] = 0;
 407                                         }
 408                                         nb_completable++;
 409                                 }
 410                         }
 411                 next:
 412                         debug_printf("next\n");
 413                         inst_num ++;
 414                         inst = ctx[inst_num];
 415                 }
 416
 417                 debug_printf("total choices %d for this completion\n",
 418                              nb_completable);
 419
 420                 /* no possible completion */
 421                 if (nb_completable == 0 && nb_non_completable == 0)
 422                         return 0;
 423
 424                 /* if multichoice is not required */
 425                 if (*state == 0 && partial_tok_len > 0) {
 426                         /* one or several choices starting with the
 427                            same chars */
 428                         if (comp_len > 0) {
 429                                 if ((unsigned)(comp_len + 1) > size)
 430                                         return 0;
 431
 432                                 strlcpy(dst, comp_buf, size);
 433                                 dst[comp_len] = 0;
 434                                 return 2;
 435                         }
 436                 }
 437         }
 438
 439         /* init state correctly */
 440         if (*state == -1)
 441                 *state = 0;
 442
 443         debug_printf("Multiple choice STATE=%d\n", *state);
 444
 445         inst_num = 0;
 446         inst = ctx[inst_num];
 447         while (inst) {
 448                 /* we need to redo it */
 449                 inst = ctx[inst_num];
 450
 451                 if (nb_token &&
 452                     match_inst(inst, buf, nb_token, NULL, 0))
 453                         goto next2;
 454
 455                 token_p = get_token(inst, nb_token);
 456                 if (token_p)
 457                         memcpy(&token_hdr, token_p, sizeof(token_hdr));
 458
 459                 /* one choice for this token */
 460                 if (!token_p ||
 461                     !token_hdr.ops->complete_get_nb ||
 462                     !token_hdr.ops->complete_get_elt ||
 463                     (n = token_hdr.ops->complete_get_nb(token_p)) == 0) {
 464                         if (local_state < *state) {
 465                                 local_state++;
 466                                 goto next2;
 467                         }
 468                         (*state)++;
 469                         if (token_p && token_hdr.ops->get_help) {
 470                                 token_hdr.ops->get_help(token_p, tmpbuf,
 471                                                         sizeof(tmpbuf));
 472                                 help_str = inst->help_str;
 473                                 if (help_str)
 474                                         snprintf(dst, size, "[%s]: %s", tmpbuf,
 475                                                  help_str);
 476                                 else
 477                                         snprintf(dst, size, "[%s]: No help",
 478                                                  tmpbuf);
 479                         }
 480                         else {
 481                                 snprintf(dst, size, "[RETURN]");
 482                         }
 483                         return 1;
 484                 }
 485
 486                 /* several choices */
 487                 for (i=0 ; i<n ; i++) {
 488                         if (token_hdr.ops->complete_get_elt(token_p, i, tmpbuf,
 489                                                             sizeof(tmpbuf)) < 0)
 490                                 continue;
 491                         /* we have at least room for one char */
 492                         tmp_len = strnlen(tmpbuf, sizeof(tmpbuf));
 493                         if (tmp_len < CMDLINE_BUFFER_SIZE - 1) {
 494                                 tmpbuf[tmp_len] = ' ';
 495                                 tmpbuf[tmp_len + 1] = 0;
 496                         }
 497
 498                         debug_printf("   choice <%s>\n", tmpbuf);
 499
 500                         /* does the completion match the beginning of
 501                          * the word ? */
 502                         if (!strncmp(partial_tok, tmpbuf,
 503                                      partial_tok_len)) {
 504                                 if (local_state < *state) {
 505                                         local_state++;
 506                                         continue;
 507                                 }
 508                                 (*state)++;
 509                                 l=strlcpy(dst, tmpbuf, size);
 510                                 if (l>=0 && token_hdr.ops->get_help) {
 511                                         token_hdr.ops->get_help(token_p, tmpbuf,
 512                                                                 sizeof(tmpbuf));
 513                                         help_str = inst->help_str;
 514                                         if (help_str)
 515                                                 snprintf(dst+l, size-l, "[%s]: %s",
 516                                                          tmpbuf, help_str);
 517                                         else
 518                                                 snprintf(dst+l, size-l,
 519                                                          "[%s]: No help", tmpbuf);
 520                                 }
 521
 522                                 return 1;
 523                         }
 524                 }
 525         next2:
 526                 inst_num ++;
 527                 inst = ctx[inst_num];
 528         }
 529         return 0;
 530 }