app/test-pmd/cmdline_flow.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright 2016 6WIND S.A.
   5  *   Copyright 2016 Mellanox.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of 6WIND S.A. 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 FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include <stddef.h>
  35 #include <stdint.h>
  36 #include <stdio.h>
  37 #include <inttypes.h>
  38 #include <errno.h>
  39 #include <ctype.h>
  40 #include <string.h>
  41 #include <arpa/inet.h>
  42 #include <sys/socket.h>
  43
  44 #include <rte_common.h>
  45 #include <rte_ethdev.h>
  46 #include <rte_byteorder.h>
  47 #include <cmdline_parse.h>
  48 #include <cmdline_parse_etheraddr.h>
  49 #include <rte_flow.h>
  50
  51 #include "testpmd.h"
  52
  53 /** Parser token indices. */
  54 enum index {
  55         /* Special tokens. */
  56         ZERO = 0,
  57         END,
  58
  59         /* Common tokens. */
  60         INTEGER,
  61         UNSIGNED,
  62         PREFIX,
  63         BOOLEAN,
  64         STRING,
  65         MAC_ADDR,
  66         IPV4_ADDR,
  67         IPV6_ADDR,
  68         RULE_ID,
  69         PORT_ID,
  70         GROUP_ID,
  71         PRIORITY_LEVEL,
  72
  73         /* Top-level command. */
  74         FLOW,
  75
  76         /* Sub-level commands. */
  77         VALIDATE,
  78         CREATE,
  79         DESTROY,
  80         FLUSH,
  81         QUERY,
  82         LIST,
  83         ISOLATE,
  84
  85         /* Destroy arguments. */
  86         DESTROY_RULE,
  87
  88         /* Query arguments. */
  89         QUERY_ACTION,
  90
  91         /* List arguments. */
  92         LIST_GROUP,
  93
  94         /* Validate/create arguments. */
  95         GROUP,
  96         PRIORITY,
  97         INGRESS,
  98         EGRESS,
  99
 100         /* Validate/create pattern. */
 101         PATTERN,
 102         ITEM_PARAM_IS,
 103         ITEM_PARAM_SPEC,
 104         ITEM_PARAM_LAST,
 105         ITEM_PARAM_MASK,
 106         ITEM_PARAM_PREFIX,
 107         ITEM_NEXT,
 108         ITEM_END,
 109         ITEM_VOID,
 110         ITEM_INVERT,
 111         ITEM_ANY,
 112         ITEM_ANY_NUM,
 113         ITEM_PF,
 114         ITEM_VF,
 115         ITEM_VF_ID,
 116         ITEM_PORT,
 117         ITEM_PORT_INDEX,
 118         ITEM_RAW,
 119         ITEM_RAW_RELATIVE,
 120         ITEM_RAW_SEARCH,
 121         ITEM_RAW_OFFSET,
 122         ITEM_RAW_LIMIT,
 123         ITEM_RAW_PATTERN,
 124         ITEM_ETH,
 125         ITEM_ETH_DST,
 126         ITEM_ETH_SRC,
 127         ITEM_ETH_TYPE,
 128         ITEM_VLAN,
 129         ITEM_VLAN_TPID,
 130         ITEM_VLAN_TCI,
 131         ITEM_VLAN_PCP,
 132         ITEM_VLAN_DEI,
 133         ITEM_VLAN_VID,
 134         ITEM_IPV4,
 135         ITEM_IPV4_TOS,
 136         ITEM_IPV4_TTL,
 137         ITEM_IPV4_PROTO,
 138         ITEM_IPV4_SRC,
 139         ITEM_IPV4_DST,
 140         ITEM_IPV6,
 141         ITEM_IPV6_TC,
 142         ITEM_IPV6_FLOW,
 143         ITEM_IPV6_PROTO,
 144         ITEM_IPV6_HOP,
 145         ITEM_IPV6_SRC,
 146         ITEM_IPV6_DST,
 147         ITEM_ICMP,
 148         ITEM_ICMP_TYPE,
 149         ITEM_ICMP_CODE,
 150         ITEM_UDP,
 151         ITEM_UDP_SRC,
 152         ITEM_UDP_DST,
 153         ITEM_TCP,
 154         ITEM_TCP_SRC,
 155         ITEM_TCP_DST,
 156         ITEM_TCP_FLAGS,
 157         ITEM_SCTP,
 158         ITEM_SCTP_SRC,
 159         ITEM_SCTP_DST,
 160         ITEM_SCTP_TAG,
 161         ITEM_SCTP_CKSUM,
 162         ITEM_VXLAN,
 163         ITEM_VXLAN_VNI,
 164         ITEM_E_TAG,
 165         ITEM_E_TAG_GRP_ECID_B,
 166         ITEM_NVGRE,
 167         ITEM_NVGRE_TNI,
 168         ITEM_MPLS,
 169         ITEM_MPLS_LABEL,
 170         ITEM_GRE,
 171         ITEM_GRE_PROTO,
 172         ITEM_FUZZY,
 173         ITEM_FUZZY_THRESH,
 174         ITEM_GTP,
 175         ITEM_GTP_TEID,
 176         ITEM_GTPC,
 177         ITEM_GTPU,
 178
 179         /* Validate/create actions. */
 180         ACTIONS,
 181         ACTION_NEXT,
 182         ACTION_END,
 183         ACTION_VOID,
 184         ACTION_PASSTHRU,
 185         ACTION_MARK,
 186         ACTION_MARK_ID,
 187         ACTION_FLAG,
 188         ACTION_QUEUE,
 189         ACTION_QUEUE_INDEX,
 190         ACTION_DROP,
 191         ACTION_COUNT,
 192         ACTION_DUP,
 193         ACTION_DUP_INDEX,
 194         ACTION_RSS,
 195         ACTION_RSS_QUEUES,
 196         ACTION_RSS_QUEUE,
 197         ACTION_PF,
 198         ACTION_VF,
 199         ACTION_VF_ORIGINAL,
 200         ACTION_VF_ID,
 201 };
 202
 203 /** Size of pattern[] field in struct rte_flow_item_raw. */
 204 #define ITEM_RAW_PATTERN_SIZE 36
 205
 206 /** Storage size for struct rte_flow_item_raw including pattern. */
 207 #define ITEM_RAW_SIZE \
 208         (offsetof(struct rte_flow_item_raw, pattern) + ITEM_RAW_PATTERN_SIZE)
 209
 210 /** Number of queue[] entries in struct rte_flow_action_rss. */
 211 #define ACTION_RSS_NUM 32
 212
 213 /** Storage size for struct rte_flow_action_rss including queues. */
 214 #define ACTION_RSS_SIZE \
 215         (offsetof(struct rte_flow_action_rss, queue) + \
 216          sizeof(*((struct rte_flow_action_rss *)0)->queue) * ACTION_RSS_NUM)
 217
 218 /** Maximum number of subsequent tokens and arguments on the stack. */
 219 #define CTX_STACK_SIZE 16
 220
 221 /** Parser context. */
 222 struct context {
 223         /** Stack of subsequent token lists to process. */
 224         const enum index *next[CTX_STACK_SIZE];
 225         /** Arguments for stacked tokens. */
 226         const void *args[CTX_STACK_SIZE];
 227         enum index curr; /**< Current token index. */
 228         enum index prev; /**< Index of the last token seen. */
 229         int next_num; /**< Number of entries in next[]. */
 230         int args_num; /**< Number of entries in args[]. */
 231         uint32_t eol:1; /**< EOL has been detected. */
 232         uint32_t last:1; /**< No more arguments. */
 233         portid_t port; /**< Current port ID (for completions). */
 234         uint32_t objdata; /**< Object-specific data. */
 235         void *object; /**< Address of current object for relative offsets. */
 236         void *objmask; /**< Object a full mask must be written to. */
 237 };
 238
 239 /** Token argument. */
 240 struct arg {
 241         uint32_t hton:1; /**< Use network byte ordering. */
 242         uint32_t sign:1; /**< Value is signed. */
 243         uint32_t offset; /**< Relative offset from ctx->object. */
 244         uint32_t size; /**< Field size. */
 245         const uint8_t *mask; /**< Bit-mask to use instead of offset/size. */
 246 };
 247
 248 /** Parser token definition. */
 249 struct token {
 250         /** Type displayed during completion (defaults to "TOKEN"). */
 251         const char *type;
 252         /** Help displayed during completion (defaults to token name). */
 253         const char *help;
 254         /** Private data used by parser functions. */
 255         const void *priv;
 256         /**
 257          * Lists of subsequent tokens to push on the stack. Each call to the
 258          * parser consumes the last entry of that stack.
 259          */
 260         const enum index *const *next;
 261         /** Arguments stack for subsequent tokens that need them. */
 262         const struct arg *const *args;
 263         /**
 264          * Token-processing callback, returns -1 in case of error, the
 265          * length of the matched string otherwise. If NULL, attempts to
 266          * match the token name.
 267          *
 268          * If buf is not NULL, the result should be stored in it according
 269          * to context. An error is returned if not large enough.
 270          */
 271         int (*call)(struct context *ctx, const struct token *token,
 272                     const char *str, unsigned int len,
 273                     void *buf, unsigned int size);
 274         /**
 275          * Callback that provides possible values for this token, used for
 276          * completion. Returns -1 in case of error, the number of possible
 277          * values otherwise. If NULL, the token name is used.
 278          *
 279          * If buf is not NULL, entry index ent is written to buf and the
 280          * full length of the entry is returned (same behavior as
 281          * snprintf()).
 282          */
 283         int (*comp)(struct context *ctx, const struct token *token,
 284                     unsigned int ent, char *buf, unsigned int size);
 285         /** Mandatory token name, no default value. */
 286         const char *name;
 287 };
 288
 289 /** Static initializer for the next field. */
 290 #define NEXT(...) (const enum index *const []){ __VA_ARGS__, NULL, }
 291
 292 /** Static initializer for a NEXT() entry. */
 293 #define NEXT_ENTRY(...) (const enum index []){ __VA_ARGS__, ZERO, }
 294
 295 /** Static initializer for the args field. */
 296 #define ARGS(...) (const struct arg *const []){ __VA_ARGS__, NULL, }
 297
 298 /** Static initializer for ARGS() to target a field. */
 299 #define ARGS_ENTRY(s, f) \
 300         (&(const struct arg){ \
 301                 .offset = offsetof(s, f), \
 302                 .size = sizeof(((s *)0)->f), \
 303         })
 304
 305 /** Static initializer for ARGS() to target a bit-field. */
 306 #define ARGS_ENTRY_BF(s, f, b) \
 307         (&(const struct arg){ \
 308                 .size = sizeof(s), \
 309                 .mask = (const void *)&(const s){ .f = (1 << (b)) - 1 }, \
 310         })
 311
 312 /** Static initializer for ARGS() to target an arbitrary bit-mask. */
 313 #define ARGS_ENTRY_MASK(s, f, m) \
 314         (&(const struct arg){ \
 315                 .offset = offsetof(s, f), \
 316                 .size = sizeof(((s *)0)->f), \
 317                 .mask = (const void *)(m), \
 318         })
 319
 320 /** Same as ARGS_ENTRY_MASK() using network byte ordering for the value. */
 321 #define ARGS_ENTRY_MASK_HTON(s, f, m) \
 322         (&(const struct arg){ \
 323                 .hton = 1, \
 324                 .offset = offsetof(s, f), \
 325                 .size = sizeof(((s *)0)->f), \
 326                 .mask = (const void *)(m), \
 327         })
 328
 329 /** Static initializer for ARGS() to target a pointer. */
 330 #define ARGS_ENTRY_PTR(s, f) \
 331         (&(const struct arg){ \
 332                 .size = sizeof(*((s *)0)->f), \
 333         })
 334
 335 /** Static initializer for ARGS() with arbitrary size. */
 336 #define ARGS_ENTRY_USZ(s, f, sz) \
 337         (&(const struct arg){ \
 338                 .offset = offsetof(s, f), \
 339                 .size = (sz), \
 340         })
 341
 342 /** Same as ARGS_ENTRY() using network byte ordering. */
 343 #define ARGS_ENTRY_HTON(s, f) \
 344         (&(const struct arg){ \
 345                 .hton = 1, \
 346                 .offset = offsetof(s, f), \
 347                 .size = sizeof(((s *)0)->f), \
 348         })
 349
 350 /** Parser output buffer layout expected by cmd_flow_parsed(). */
 351 struct buffer {
 352         enum index command; /**< Flow command. */
 353         portid_t port; /**< Affected port ID. */
 354         union {
 355                 struct {
 356                         struct rte_flow_attr attr;
 357                         struct rte_flow_item *pattern;
 358                         struct rte_flow_action *actions;
 359                         uint32_t pattern_n;
 360                         uint32_t actions_n;
 361                         uint8_t *data;
 362                 } vc; /**< Validate/create arguments. */
 363                 struct {
 364                         uint32_t *rule;
 365                         uint32_t rule_n;
 366                 } destroy; /**< Destroy arguments. */
 367                 struct {
 368                         uint32_t rule;
 369                         enum rte_flow_action_type action;
 370                 } query; /**< Query arguments. */
 371                 struct {
 372                         uint32_t *group;
 373                         uint32_t group_n;
 374                 } list; /**< List arguments. */
 375                 struct {
 376                         int set;
 377                 } isolate; /**< Isolated mode arguments. */
 378         } args; /**< Command arguments. */
 379 };
 380
 381 /** Private data for pattern items. */
 382 struct parse_item_priv {
 383         enum rte_flow_item_type type; /**< Item type. */
 384         uint32_t size; /**< Size of item specification structure. */
 385 };
 386
 387 #define PRIV_ITEM(t, s) \
 388         (&(const struct parse_item_priv){ \
 389                 .type = RTE_FLOW_ITEM_TYPE_ ## t, \
 390                 .size = s, \
 391         })
 392
 393 /** Private data for actions. */
 394 struct parse_action_priv {
 395         enum rte_flow_action_type type; /**< Action type. */
 396         uint32_t size; /**< Size of action configuration structure. */
 397 };
 398
 399 #define PRIV_ACTION(t, s) \
 400         (&(const struct parse_action_priv){ \
 401                 .type = RTE_FLOW_ACTION_TYPE_ ## t, \
 402                 .size = s, \
 403         })
 404
 405 static const enum index next_vc_attr[] = {
 406         GROUP,
 407         PRIORITY,
 408         INGRESS,
 409         EGRESS,
 410         PATTERN,
 411         ZERO,
 412 };
 413
 414 static const enum index next_destroy_attr[] = {
 415         DESTROY_RULE,
 416         END,
 417         ZERO,
 418 };
 419
 420 static const enum index next_list_attr[] = {
 421         LIST_GROUP,
 422         END,
 423         ZERO,
 424 };
 425
 426 static const enum index item_param[] = {
 427         ITEM_PARAM_IS,
 428         ITEM_PARAM_SPEC,
 429         ITEM_PARAM_LAST,
 430         ITEM_PARAM_MASK,
 431         ITEM_PARAM_PREFIX,
 432         ZERO,
 433 };
 434
 435 static const enum index next_item[] = {
 436         ITEM_END,
 437         ITEM_VOID,
 438         ITEM_INVERT,
 439         ITEM_ANY,
 440         ITEM_PF,
 441         ITEM_VF,
 442         ITEM_PORT,
 443         ITEM_RAW,
 444         ITEM_ETH,
 445         ITEM_VLAN,
 446         ITEM_IPV4,
 447         ITEM_IPV6,
 448         ITEM_ICMP,
 449         ITEM_UDP,
 450         ITEM_TCP,
 451         ITEM_SCTP,
 452         ITEM_VXLAN,
 453         ITEM_E_TAG,
 454         ITEM_NVGRE,
 455         ITEM_MPLS,
 456         ITEM_GRE,
 457         ITEM_FUZZY,
 458         ITEM_GTP,
 459         ITEM_GTPC,
 460         ITEM_GTPU,
 461         ZERO,
 462 };
 463
 464 static const enum index item_fuzzy[] = {
 465         ITEM_FUZZY_THRESH,
 466         ITEM_NEXT,
 467         ZERO,
 468 };
 469
 470 static const enum index item_any[] = {
 471         ITEM_ANY_NUM,
 472         ITEM_NEXT,
 473         ZERO,
 474 };
 475
 476 static const enum index item_vf[] = {
 477         ITEM_VF_ID,
 478         ITEM_NEXT,
 479         ZERO,
 480 };
 481
 482 static const enum index item_port[] = {
 483         ITEM_PORT_INDEX,
 484         ITEM_NEXT,
 485         ZERO,
 486 };
 487
 488 static const enum index item_raw[] = {
 489         ITEM_RAW_RELATIVE,
 490         ITEM_RAW_SEARCH,
 491         ITEM_RAW_OFFSET,
 492         ITEM_RAW_LIMIT,
 493         ITEM_RAW_PATTERN,
 494         ITEM_NEXT,
 495         ZERO,
 496 };
 497
 498 static const enum index item_eth[] = {
 499         ITEM_ETH_DST,
 500         ITEM_ETH_SRC,
 501         ITEM_ETH_TYPE,
 502         ITEM_NEXT,
 503         ZERO,
 504 };
 505
 506 static const enum index item_vlan[] = {
 507         ITEM_VLAN_TPID,
 508         ITEM_VLAN_TCI,
 509         ITEM_VLAN_PCP,
 510         ITEM_VLAN_DEI,
 511         ITEM_VLAN_VID,
 512         ITEM_NEXT,
 513         ZERO,
 514 };
 515
 516 static const enum index item_ipv4[] = {
 517         ITEM_IPV4_TOS,
 518         ITEM_IPV4_TTL,
 519         ITEM_IPV4_PROTO,
 520         ITEM_IPV4_SRC,
 521         ITEM_IPV4_DST,
 522         ITEM_NEXT,
 523         ZERO,
 524 };
 525
 526 static const enum index item_ipv6[] = {
 527         ITEM_IPV6_TC,
 528         ITEM_IPV6_FLOW,
 529         ITEM_IPV6_PROTO,
 530         ITEM_IPV6_HOP,
 531         ITEM_IPV6_SRC,
 532         ITEM_IPV6_DST,
 533         ITEM_NEXT,
 534         ZERO,
 535 };
 536
 537 static const enum index item_icmp[] = {
 538         ITEM_ICMP_TYPE,
 539         ITEM_ICMP_CODE,
 540         ITEM_NEXT,
 541         ZERO,
 542 };
 543
 544 static const enum index item_udp[] = {
 545         ITEM_UDP_SRC,
 546         ITEM_UDP_DST,
 547         ITEM_NEXT,
 548         ZERO,
 549 };
 550
 551 static const enum index item_tcp[] = {
 552         ITEM_TCP_SRC,
 553         ITEM_TCP_DST,
 554         ITEM_TCP_FLAGS,
 555         ITEM_NEXT,
 556         ZERO,
 557 };
 558
 559 static const enum index item_sctp[] = {
 560         ITEM_SCTP_SRC,
 561         ITEM_SCTP_DST,
 562         ITEM_SCTP_TAG,
 563         ITEM_SCTP_CKSUM,
 564         ITEM_NEXT,
 565         ZERO,
 566 };
 567
 568 static const enum index item_vxlan[] = {
 569         ITEM_VXLAN_VNI,
 570         ITEM_NEXT,
 571         ZERO,
 572 };
 573
 574 static const enum index item_e_tag[] = {
 575         ITEM_E_TAG_GRP_ECID_B,
 576         ITEM_NEXT,
 577         ZERO,
 578 };
 579
 580 static const enum index item_nvgre[] = {
 581         ITEM_NVGRE_TNI,
 582         ITEM_NEXT,
 583         ZERO,
 584 };
 585
 586 static const enum index item_mpls[] = {
 587         ITEM_MPLS_LABEL,
 588         ITEM_NEXT,
 589         ZERO,
 590 };
 591
 592 static const enum index item_gre[] = {
 593         ITEM_GRE_PROTO,
 594         ITEM_NEXT,
 595         ZERO,
 596 };
 597
 598 static const enum index item_gtp[] = {
 599         ITEM_GTP_TEID,
 600         ITEM_NEXT,
 601         ZERO,
 602 };
 603
 604 static const enum index next_action[] = {
 605         ACTION_END,
 606         ACTION_VOID,
 607         ACTION_PASSTHRU,
 608         ACTION_MARK,
 609         ACTION_FLAG,
 610         ACTION_QUEUE,
 611         ACTION_DROP,
 612         ACTION_COUNT,
 613         ACTION_DUP,
 614         ACTION_RSS,
 615         ACTION_PF,
 616         ACTION_VF,
 617         ZERO,
 618 };
 619
 620 static const enum index action_mark[] = {
 621         ACTION_MARK_ID,
 622         ACTION_NEXT,
 623         ZERO,
 624 };
 625
 626 static const enum index action_queue[] = {
 627         ACTION_QUEUE_INDEX,
 628         ACTION_NEXT,
 629         ZERO,
 630 };
 631
 632 static const enum index action_dup[] = {
 633         ACTION_DUP_INDEX,
 634         ACTION_NEXT,
 635         ZERO,
 636 };
 637
 638 static const enum index action_rss[] = {
 639         ACTION_RSS_QUEUES,
 640         ACTION_NEXT,
 641         ZERO,
 642 };
 643
 644 static const enum index action_vf[] = {
 645         ACTION_VF_ORIGINAL,
 646         ACTION_VF_ID,
 647         ACTION_NEXT,
 648         ZERO,
 649 };
 650
 651 static int parse_init(struct context *, const struct token *,
 652                       const char *, unsigned int,
 653                       void *, unsigned int);
 654 static int parse_vc(struct context *, const struct token *,
 655                     const char *, unsigned int,
 656                     void *, unsigned int);
 657 static int parse_vc_spec(struct context *, const struct token *,
 658                          const char *, unsigned int, void *, unsigned int);
 659 static int parse_vc_conf(struct context *, const struct token *,
 660                          const char *, unsigned int, void *, unsigned int);
 661 static int parse_vc_action_rss_queue(struct context *, const struct token *,
 662                                      const char *, unsigned int, void *,
 663                                      unsigned int);
 664 static int parse_destroy(struct context *, const struct token *,
 665                          const char *, unsigned int,
 666                          void *, unsigned int);
 667 static int parse_flush(struct context *, const struct token *,
 668                        const char *, unsigned int,
 669                        void *, unsigned int);
 670 static int parse_query(struct context *, const struct token *,
 671                        const char *, unsigned int,
 672                        void *, unsigned int);
 673 static int parse_action(struct context *, const struct token *,
 674                         const char *, unsigned int,
 675                         void *, unsigned int);
 676 static int parse_list(struct context *, const struct token *,
 677                       const char *, unsigned int,
 678                       void *, unsigned int);
 679 static int parse_isolate(struct context *, const struct token *,
 680                          const char *, unsigned int,
 681                          void *, unsigned int);
 682 static int parse_int(struct context *, const struct token *,
 683                      const char *, unsigned int,
 684                      void *, unsigned int);
 685 static int parse_prefix(struct context *, const struct token *,
 686                         const char *, unsigned int,
 687                         void *, unsigned int);
 688 static int parse_boolean(struct context *, const struct token *,
 689                          const char *, unsigned int,
 690                          void *, unsigned int);
 691 static int parse_string(struct context *, const struct token *,
 692                         const char *, unsigned int,
 693                         void *, unsigned int);
 694 static int parse_mac_addr(struct context *, const struct token *,
 695                           const char *, unsigned int,
 696                           void *, unsigned int);
 697 static int parse_ipv4_addr(struct context *, const struct token *,
 698                            const char *, unsigned int,
 699                            void *, unsigned int);
 700 static int parse_ipv6_addr(struct context *, const struct token *,
 701                            const char *, unsigned int,
 702                            void *, unsigned int);
 703 static int parse_port(struct context *, const struct token *,
 704                       const char *, unsigned int,
 705                       void *, unsigned int);
 706 static int comp_none(struct context *, const struct token *,
 707                      unsigned int, char *, unsigned int);
 708 static int comp_boolean(struct context *, const struct token *,
 709                         unsigned int, char *, unsigned int);
 710 static int comp_action(struct context *, const struct token *,
 711                        unsigned int, char *, unsigned int);
 712 static int comp_port(struct context *, const struct token *,
 713                      unsigned int, char *, unsigned int);
 714 static int comp_rule_id(struct context *, const struct token *,
 715                         unsigned int, char *, unsigned int);
 716 static int comp_vc_action_rss_queue(struct context *, const struct token *,
 717                                     unsigned int, char *, unsigned int);
 718
 719 /** Token definitions. */
 720 static const struct token token_list[] = {
 721         /* Special tokens. */
 722         [ZERO] = {
 723                 .name = "ZERO",
 724                 .help = "null entry, abused as the entry point",
 725                 .next = NEXT(NEXT_ENTRY(FLOW)),
 726         },
 727         [END] = {
 728                 .name = "",
 729                 .type = "RETURN",
 730                 .help = "command may end here",
 731         },
 732         /* Common tokens. */
 733         [INTEGER] = {
 734                 .name = "{int}",
 735                 .type = "INTEGER",
 736                 .help = "integer value",
 737                 .call = parse_int,
 738                 .comp = comp_none,
 739         },
 740         [UNSIGNED] = {
 741                 .name = "{unsigned}",
 742                 .type = "UNSIGNED",
 743                 .help = "unsigned integer value",
 744                 .call = parse_int,
 745                 .comp = comp_none,
 746         },
 747         [PREFIX] = {
 748                 .name = "{prefix}",
 749                 .type = "PREFIX",
 750                 .help = "prefix length for bit-mask",
 751                 .call = parse_prefix,
 752                 .comp = comp_none,
 753         },
 754         [BOOLEAN] = {
 755                 .name = "{boolean}",
 756                 .type = "BOOLEAN",
 757                 .help = "any boolean value",
 758                 .call = parse_boolean,
 759                 .comp = comp_boolean,
 760         },
 761         [STRING] = {
 762                 .name = "{string}",
 763                 .type = "STRING",
 764                 .help = "fixed string",
 765                 .call = parse_string,
 766                 .comp = comp_none,
 767         },
 768         [MAC_ADDR] = {
 769                 .name = "{MAC address}",
 770                 .type = "MAC-48",
 771                 .help = "standard MAC address notation",
 772                 .call = parse_mac_addr,
 773                 .comp = comp_none,
 774         },
 775         [IPV4_ADDR] = {
 776                 .name = "{IPv4 address}",
 777                 .type = "IPV4 ADDRESS",
 778                 .help = "standard IPv4 address notation",
 779                 .call = parse_ipv4_addr,
 780                 .comp = comp_none,
 781         },
 782         [IPV6_ADDR] = {
 783                 .name = "{IPv6 address}",
 784                 .type = "IPV6 ADDRESS",
 785                 .help = "standard IPv6 address notation",
 786                 .call = parse_ipv6_addr,
 787                 .comp = comp_none,
 788         },
 789         [RULE_ID] = {
 790                 .name = "{rule id}",
 791                 .type = "RULE ID",
 792                 .help = "rule identifier",
 793                 .call = parse_int,
 794                 .comp = comp_rule_id,
 795         },
 796         [PORT_ID] = {
 797                 .name = "{port_id}",
 798                 .type = "PORT ID",
 799                 .help = "port identifier",
 800                 .call = parse_port,
 801                 .comp = comp_port,
 802         },
 803         [GROUP_ID] = {
 804                 .name = "{group_id}",
 805                 .type = "GROUP ID",
 806                 .help = "group identifier",
 807                 .call = parse_int,
 808                 .comp = comp_none,
 809         },
 810         [PRIORITY_LEVEL] = {
 811                 .name = "{level}",
 812                 .type = "PRIORITY",
 813                 .help = "priority level",
 814                 .call = parse_int,
 815                 .comp = comp_none,
 816         },
 817         /* Top-level command. */
 818         [FLOW] = {
 819                 .name = "flow",
 820                 .type = "{command} {port_id} [{arg} [...]]",
 821                 .help = "manage ingress/egress flow rules",
 822                 .next = NEXT(NEXT_ENTRY
 823                              (VALIDATE,
 824                               CREATE,
 825                               DESTROY,
 826                               FLUSH,
 827                               LIST,
 828                               QUERY,
 829                               ISOLATE)),
 830                 .call = parse_init,
 831         },
 832         /* Sub-level commands. */
 833         [VALIDATE] = {
 834                 .name = "validate",
 835                 .help = "check whether a flow rule can be created",
 836                 .next = NEXT(next_vc_attr, NEXT_ENTRY(PORT_ID)),
 837                 .args = ARGS(ARGS_ENTRY(struct buffer, port)),
 838                 .call = parse_vc,
 839         },
 840         [CREATE] = {
 841                 .name = "create",
 842                 .help = "create a flow rule",
 843                 .next = NEXT(next_vc_attr, NEXT_ENTRY(PORT_ID)),
 844                 .args = ARGS(ARGS_ENTRY(struct buffer, port)),
 845                 .call = parse_vc,
 846         },
 847         [DESTROY] = {
 848                 .name = "destroy",
 849                 .help = "destroy specific flow rules",
 850                 .next = NEXT(NEXT_ENTRY(DESTROY_RULE), NEXT_ENTRY(PORT_ID)),
 851                 .args = ARGS(ARGS_ENTRY(struct buffer, port)),
 852                 .call = parse_destroy,
 853         },
 854         [FLUSH] = {
 855                 .name = "flush",
 856                 .help = "destroy all flow rules",
 857                 .next = NEXT(NEXT_ENTRY(PORT_ID)),
 858                 .args = ARGS(ARGS_ENTRY(struct buffer, port)),
 859                 .call = parse_flush,
 860         },
 861         [QUERY] = {
 862                 .name = "query",
 863                 .help = "query an existing flow rule",
 864                 .next = NEXT(NEXT_ENTRY(QUERY_ACTION),
 865                              NEXT_ENTRY(RULE_ID),
 866                              NEXT_ENTRY(PORT_ID)),
 867                 .args = ARGS(ARGS_ENTRY(struct buffer, args.query.action),
 868                              ARGS_ENTRY(struct buffer, args.query.rule),
 869                              ARGS_ENTRY(struct buffer, port)),
 870                 .call = parse_query,
 871         },
 872         [LIST] = {
 873                 .name = "list",
 874                 .help = "list existing flow rules",
 875                 .next = NEXT(next_list_attr, NEXT_ENTRY(PORT_ID)),
 876                 .args = ARGS(ARGS_ENTRY(struct buffer, port)),
 877                 .call = parse_list,
 878         },
 879         [ISOLATE] = {
 880                 .name = "isolate",
 881                 .help = "restrict ingress traffic to the defined flow rules",
 882                 .next = NEXT(NEXT_ENTRY(BOOLEAN),
 883                              NEXT_ENTRY(PORT_ID)),
 884                 .args = ARGS(ARGS_ENTRY(struct buffer, args.isolate.set),
 885                              ARGS_ENTRY(struct buffer, port)),
 886                 .call = parse_isolate,
 887         },
 888         /* Destroy arguments. */
 889         [DESTROY_RULE] = {
 890                 .name = "rule",
 891                 .help = "specify a rule identifier",
 892                 .next = NEXT(next_destroy_attr, NEXT_ENTRY(RULE_ID)),
 893                 .args = ARGS(ARGS_ENTRY_PTR(struct buffer, args.destroy.rule)),
 894                 .call = parse_destroy,
 895         },
 896         /* Query arguments. */
 897         [QUERY_ACTION] = {
 898                 .name = "{action}",
 899                 .type = "ACTION",
 900                 .help = "action to query, must be part of the rule",
 901                 .call = parse_action,
 902                 .comp = comp_action,
 903         },
 904         /* List arguments. */
 905         [LIST_GROUP] = {
 906                 .name = "group",
 907                 .help = "specify a group",
 908                 .next = NEXT(next_list_attr, NEXT_ENTRY(GROUP_ID)),
 909                 .args = ARGS(ARGS_ENTRY_PTR(struct buffer, args.list.group)),
 910                 .call = parse_list,
 911         },
 912         /* Validate/create attributes. */
 913         [GROUP] = {
 914                 .name = "group",
 915                 .help = "specify a group",
 916                 .next = NEXT(next_vc_attr, NEXT_ENTRY(GROUP_ID)),
 917                 .args = ARGS(ARGS_ENTRY(struct rte_flow_attr, group)),
 918                 .call = parse_vc,
 919         },
 920         [PRIORITY] = {
 921                 .name = "priority",
 922                 .help = "specify a priority level",
 923                 .next = NEXT(next_vc_attr, NEXT_ENTRY(PRIORITY_LEVEL)),
 924                 .args = ARGS(ARGS_ENTRY(struct rte_flow_attr, priority)),
 925                 .call = parse_vc,
 926         },
 927         [INGRESS] = {
 928                 .name = "ingress",
 929                 .help = "affect rule to ingress",
 930                 .next = NEXT(next_vc_attr),
 931                 .call = parse_vc,
 932         },
 933         [EGRESS] = {
 934                 .name = "egress",
 935                 .help = "affect rule to egress",
 936                 .next = NEXT(next_vc_attr),
 937                 .call = parse_vc,
 938         },
 939         /* Validate/create pattern. */
 940         [PATTERN] = {
 941                 .name = "pattern",
 942                 .help = "submit a list of pattern items",
 943                 .next = NEXT(next_item),
 944                 .call = parse_vc,
 945         },
 946         [ITEM_PARAM_IS] = {
 947                 .name = "is",
 948                 .help = "match value perfectly (with full bit-mask)",
 949                 .call = parse_vc_spec,
 950         },
 951         [ITEM_PARAM_SPEC] = {
 952                 .name = "spec",
 953                 .help = "match value according to configured bit-mask",
 954                 .call = parse_vc_spec,
 955         },
 956         [ITEM_PARAM_LAST] = {
 957                 .name = "last",
 958                 .help = "specify upper bound to establish a range",
 959                 .call = parse_vc_spec,
 960         },
 961         [ITEM_PARAM_MASK] = {
 962                 .name = "mask",
 963                 .help = "specify bit-mask with relevant bits set to one",
 964                 .call = parse_vc_spec,
 965         },
 966         [ITEM_PARAM_PREFIX] = {
 967                 .name = "prefix",
 968                 .help = "generate bit-mask from a prefix length",
 969                 .call = parse_vc_spec,
 970         },
 971         [ITEM_NEXT] = {
 972                 .name = "/",
 973                 .help = "specify next pattern item",
 974                 .next = NEXT(next_item),
 975         },
 976         [ITEM_END] = {
 977                 .name = "end",
 978                 .help = "end list of pattern items",
 979                 .priv = PRIV_ITEM(END, 0),
 980                 .next = NEXT(NEXT_ENTRY(ACTIONS)),
 981                 .call = parse_vc,
 982         },
 983         [ITEM_VOID] = {
 984                 .name = "void",
 985                 .help = "no-op pattern item",
 986                 .priv = PRIV_ITEM(VOID, 0),
 987                 .next = NEXT(NEXT_ENTRY(ITEM_NEXT)),
 988                 .call = parse_vc,
 989         },
 990         [ITEM_INVERT] = {
 991                 .name = "invert",
 992                 .help = "perform actions when pattern does not match",
 993                 .priv = PRIV_ITEM(INVERT, 0),
 994                 .next = NEXT(NEXT_ENTRY(ITEM_NEXT)),
 995                 .call = parse_vc,
 996         },
 997         [ITEM_ANY] = {
 998                 .name = "any",
 999                 .help = "match any protocol for the current layer",
1000                 .priv = PRIV_ITEM(ANY, sizeof(struct rte_flow_item_any)),
1001                 .next = NEXT(item_any),
1002                 .call = parse_vc,
1003         },
1004         [ITEM_ANY_NUM] = {
1005                 .name = "num",
1006                 .help = "number of layers covered",
1007                 .next = NEXT(item_any, NEXT_ENTRY(UNSIGNED), item_param),
1008                 .args = ARGS(ARGS_ENTRY(struct rte_flow_item_any, num)),
1009         },
1010         [ITEM_PF] = {
1011                 .name = "pf",
1012                 .help = "match packets addressed to the physical function",
1013                 .priv = PRIV_ITEM(PF, 0),
1014                 .next = NEXT(NEXT_ENTRY(ITEM_NEXT)),
1015                 .call = parse_vc,
1016         },
1017         [ITEM_VF] = {
1018                 .name = "vf",
1019                 .help = "match packets addressed to a virtual function ID",
1020                 .priv = PRIV_ITEM(VF, sizeof(struct rte_flow_item_vf)),
1021                 .next = NEXT(item_vf),
1022                 .call = parse_vc,
1023         },
1024         [ITEM_VF_ID] = {
1025                 .name = "id",
1026                 .help = "destination VF ID",
1027                 .next = NEXT(item_vf, NEXT_ENTRY(UNSIGNED), item_param),
1028                 .args = ARGS(ARGS_ENTRY(struct rte_flow_item_vf, id)),
1029         },
1030         [ITEM_PORT] = {
1031                 .name = "port",
1032                 .help = "device-specific physical port index to use",
1033                 .priv = PRIV_ITEM(PORT, sizeof(struct rte_flow_item_port)),
1034                 .next = NEXT(item_port),
1035                 .call = parse_vc,
1036         },
1037         [ITEM_PORT_INDEX] = {
1038                 .name = "index",
1039                 .help = "physical port index",
1040                 .next = NEXT(item_port, NEXT_ENTRY(UNSIGNED), item_param),
1041                 .args = ARGS(ARGS_ENTRY(struct rte_flow_item_port, index)),
1042         },
1043         [ITEM_RAW] = {
1044                 .name = "raw",
1045                 .help = "match an arbitrary byte string",
1046                 .priv = PRIV_ITEM(RAW, ITEM_RAW_SIZE),
1047                 .next = NEXT(item_raw),
1048                 .call = parse_vc,
1049         },
1050         [ITEM_RAW_RELATIVE] = {
1051                 .name = "relative",
1052                 .help = "look for pattern after the previous item",
1053                 .next = NEXT(item_raw, NEXT_ENTRY(BOOLEAN), item_param),
1054                 .args = ARGS(ARGS_ENTRY_BF(struct rte_flow_item_raw,
1055                                            relative, 1)),
1056         },
1057         [ITEM_RAW_SEARCH] = {
1058                 .name = "search",
1059                 .help = "search pattern from offset (see also limit)",
1060                 .next = NEXT(item_raw, NEXT_ENTRY(BOOLEAN), item_param),
1061                 .args = ARGS(ARGS_ENTRY_BF(struct rte_flow_item_raw,
1062                                            search, 1)),
1063         },
1064         [ITEM_RAW_OFFSET] = {
1065                 .name = "offset",
1066                 .help = "absolute or relative offset for pattern",
1067                 .next = NEXT(item_raw, NEXT_ENTRY(INTEGER), item_param),
1068                 .args = ARGS(ARGS_ENTRY(struct rte_flow_item_raw, offset)),
1069         },
1070         [ITEM_RAW_LIMIT] = {
1071                 .name = "limit",
1072                 .help = "search area limit for start of pattern",
1073                 .next = NEXT(item_raw, NEXT_ENTRY(UNSIGNED), item_param),
1074                 .args = ARGS(ARGS_ENTRY(struct rte_flow_item_raw, limit)),
1075         },
1076         [ITEM_RAW_PATTERN] = {
1077                 .name = "pattern",
1078                 .help = "byte string to look for",
1079                 .next = NEXT(item_raw,
1080                              NEXT_ENTRY(STRING),
1081                              NEXT_ENTRY(ITEM_PARAM_IS,
1082                                         ITEM_PARAM_SPEC,
1083                                         ITEM_PARAM_MASK)),
1084                 .args = ARGS(ARGS_ENTRY(struct rte_flow_item_raw, length),
1085                              ARGS_ENTRY_USZ(struct rte_flow_item_raw,
1086                                             pattern,
1087                                             ITEM_RAW_PATTERN_SIZE)),
1088         },
1089         [ITEM_ETH] = {
1090                 .name = "eth",
1091                 .help = "match Ethernet header",
1092                 .priv = PRIV_ITEM(ETH, sizeof(struct rte_flow_item_eth)),
1093                 .next = NEXT(item_eth),
1094                 .call = parse_vc,
1095         },
1096         [ITEM_ETH_DST] = {
1097                 .name = "dst",
1098                 .help = "destination MAC",
1099                 .next = NEXT(item_eth, NEXT_ENTRY(MAC_ADDR), item_param),
1100                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_eth, dst)),
1101         },
1102         [ITEM_ETH_SRC] = {
1103                 .name = "src",
1104                 .help = "source MAC",
1105                 .next = NEXT(item_eth, NEXT_ENTRY(MAC_ADDR), item_param),
1106                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_eth, src)),
1107         },
1108         [ITEM_ETH_TYPE] = {
1109                 .name = "type",
1110                 .help = "EtherType",
1111                 .next = NEXT(item_eth, NEXT_ENTRY(UNSIGNED), item_param),
1112                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_eth, type)),
1113         },
1114         [ITEM_VLAN] = {
1115                 .name = "vlan",
1116                 .help = "match 802.1Q/ad VLAN tag",
1117                 .priv = PRIV_ITEM(VLAN, sizeof(struct rte_flow_item_vlan)),
1118                 .next = NEXT(item_vlan),
1119                 .call = parse_vc,
1120         },
1121         [ITEM_VLAN_TPID] = {
1122                 .name = "tpid",
1123                 .help = "tag protocol identifier",
1124                 .next = NEXT(item_vlan, NEXT_ENTRY(UNSIGNED), item_param),
1125                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_vlan, tpid)),
1126         },
1127         [ITEM_VLAN_TCI] = {
1128                 .name = "tci",
1129                 .help = "tag control information",
1130                 .next = NEXT(item_vlan, NEXT_ENTRY(UNSIGNED), item_param),
1131                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_vlan, tci)),
1132         },
1133         [ITEM_VLAN_PCP] = {
1134                 .name = "pcp",
1135                 .help = "priority code point",
1136                 .next = NEXT(item_vlan, NEXT_ENTRY(UNSIGNED), item_param),
1137                 .args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_vlan,
1138                                                   tci, "\xe0\x00")),
1139         },
1140         [ITEM_VLAN_DEI] = {
1141                 .name = "dei",
1142                 .help = "drop eligible indicator",
1143                 .next = NEXT(item_vlan, NEXT_ENTRY(UNSIGNED), item_param),
1144                 .args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_vlan,
1145                                                   tci, "\x10\x00")),
1146         },
1147         [ITEM_VLAN_VID] = {
1148                 .name = "vid",
1149                 .help = "VLAN identifier",
1150                 .next = NEXT(item_vlan, NEXT_ENTRY(UNSIGNED), item_param),
1151                 .args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_vlan,
1152                                                   tci, "\x0f\xff")),
1153         },
1154         [ITEM_IPV4] = {
1155                 .name = "ipv4",
1156                 .help = "match IPv4 header",
1157                 .priv = PRIV_ITEM(IPV4, sizeof(struct rte_flow_item_ipv4)),
1158                 .next = NEXT(item_ipv4),
1159                 .call = parse_vc,
1160         },
1161         [ITEM_IPV4_TOS] = {
1162                 .name = "tos",
1163                 .help = "type of service",
1164                 .next = NEXT(item_ipv4, NEXT_ENTRY(UNSIGNED), item_param),
1165                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv4,
1166                                              hdr.type_of_service)),
1167         },
1168         [ITEM_IPV4_TTL] = {
1169                 .name = "ttl",
1170                 .help = "time to live",
1171                 .next = NEXT(item_ipv4, NEXT_ENTRY(UNSIGNED), item_param),
1172                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv4,
1173                                              hdr.time_to_live)),
1174         },
1175         [ITEM_IPV4_PROTO] = {
1176                 .name = "proto",
1177                 .help = "next protocol ID",
1178                 .next = NEXT(item_ipv4, NEXT_ENTRY(UNSIGNED), item_param),
1179                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv4,
1180                                              hdr.next_proto_id)),
1181         },
1182         [ITEM_IPV4_SRC] = {
1183                 .name = "src",
1184                 .help = "source address",
1185                 .next = NEXT(item_ipv4, NEXT_ENTRY(IPV4_ADDR), item_param),
1186                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv4,
1187                                              hdr.src_addr)),
1188         },
1189         [ITEM_IPV4_DST] = {
1190                 .name = "dst",
1191                 .help = "destination address",
1192                 .next = NEXT(item_ipv4, NEXT_ENTRY(IPV4_ADDR), item_param),
1193                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv4,
1194                                              hdr.dst_addr)),
1195         },
1196         [ITEM_IPV6] = {
1197                 .name = "ipv6",
1198                 .help = "match IPv6 header",
1199                 .priv = PRIV_ITEM(IPV6, sizeof(struct rte_flow_item_ipv6)),
1200                 .next = NEXT(item_ipv6),
1201                 .call = parse_vc,
1202         },
1203         [ITEM_IPV6_TC] = {
1204                 .name = "tc",
1205                 .help = "traffic class",
1206                 .next = NEXT(item_ipv6, NEXT_ENTRY(UNSIGNED), item_param),
1207                 .args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_ipv6,
1208                                                   hdr.vtc_flow,
1209                                                   "\x0f\xf0\x00\x00")),
1210         },
1211         [ITEM_IPV6_FLOW] = {
1212                 .name = "flow",
1213                 .help = "flow label",
1214                 .next = NEXT(item_ipv6, NEXT_ENTRY(UNSIGNED), item_param),
1215                 .args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_ipv6,
1216                                                   hdr.vtc_flow,
1217                                                   "\x00\x0f\xff\xff")),
1218         },
1219         [ITEM_IPV6_PROTO] = {
1220                 .name = "proto",
1221                 .help = "protocol (next header)",
1222                 .next = NEXT(item_ipv6, NEXT_ENTRY(UNSIGNED), item_param),
1223                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv6,
1224                                              hdr.proto)),
1225         },
1226         [ITEM_IPV6_HOP] = {
1227                 .name = "hop",
1228                 .help = "hop limit",
1229                 .next = NEXT(item_ipv6, NEXT_ENTRY(UNSIGNED), item_param),
1230                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv6,
1231                                              hdr.hop_limits)),
1232         },
1233         [ITEM_IPV6_SRC] = {
1234                 .name = "src",
1235                 .help = "source address",
1236                 .next = NEXT(item_ipv6, NEXT_ENTRY(IPV6_ADDR), item_param),
1237                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv6,
1238                                              hdr.src_addr)),
1239         },
1240         [ITEM_IPV6_DST] = {
1241                 .name = "dst",
1242                 .help = "destination address",
1243                 .next = NEXT(item_ipv6, NEXT_ENTRY(IPV6_ADDR), item_param),
1244                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv6,
1245                                              hdr.dst_addr)),
1246         },
1247         [ITEM_ICMP] = {
1248                 .name = "icmp",
1249                 .help = "match ICMP header",
1250                 .priv = PRIV_ITEM(ICMP, sizeof(struct rte_flow_item_icmp)),
1251                 .next = NEXT(item_icmp),
1252                 .call = parse_vc,
1253         },
1254         [ITEM_ICMP_TYPE] = {
1255                 .name = "type",
1256                 .help = "ICMP packet type",
1257                 .next = NEXT(item_icmp, NEXT_ENTRY(UNSIGNED), item_param),
1258                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_icmp,
1259                                              hdr.icmp_type)),
1260         },
1261         [ITEM_ICMP_CODE] = {
1262                 .name = "code",
1263                 .help = "ICMP packet code",
1264                 .next = NEXT(item_icmp, NEXT_ENTRY(UNSIGNED), item_param),
1265                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_icmp,
1266                                              hdr.icmp_code)),
1267         },
1268         [ITEM_UDP] = {
1269                 .name = "udp",
1270                 .help = "match UDP header",
1271                 .priv = PRIV_ITEM(UDP, sizeof(struct rte_flow_item_udp)),
1272                 .next = NEXT(item_udp),
1273                 .call = parse_vc,
1274         },
1275         [ITEM_UDP_SRC] = {
1276                 .name = "src",
1277                 .help = "UDP source port",
1278                 .next = NEXT(item_udp, NEXT_ENTRY(UNSIGNED), item_param),
1279                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_udp,
1280                                              hdr.src_port)),
1281         },
1282         [ITEM_UDP_DST] = {
1283                 .name = "dst",
1284                 .help = "UDP destination port",
1285                 .next = NEXT(item_udp, NEXT_ENTRY(UNSIGNED), item_param),
1286                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_udp,
1287                                              hdr.dst_port)),
1288         },
1289         [ITEM_TCP] = {
1290                 .name = "tcp",
1291                 .help = "match TCP header",
1292                 .priv = PRIV_ITEM(TCP, sizeof(struct rte_flow_item_tcp)),
1293                 .next = NEXT(item_tcp),
1294                 .call = parse_vc,
1295         },
1296         [ITEM_TCP_SRC] = {
1297                 .name = "src",
1298                 .help = "TCP source port",
1299                 .next = NEXT(item_tcp, NEXT_ENTRY(UNSIGNED), item_param),
1300                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_tcp,
1301                                              hdr.src_port)),
1302         },
1303         [ITEM_TCP_DST] = {
1304                 .name = "dst",
1305                 .help = "TCP destination port",
1306                 .next = NEXT(item_tcp, NEXT_ENTRY(UNSIGNED), item_param),
1307                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_tcp,
1308                                              hdr.dst_port)),
1309         },
1310         [ITEM_TCP_FLAGS] = {
1311                 .name = "flags",
1312                 .help = "TCP flags",
1313                 .next = NEXT(item_tcp, NEXT_ENTRY(UNSIGNED), item_param),
1314                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_tcp,
1315                                              hdr.tcp_flags)),
1316         },
1317         [ITEM_SCTP] = {
1318                 .name = "sctp",
1319                 .help = "match SCTP header",
1320                 .priv = PRIV_ITEM(SCTP, sizeof(struct rte_flow_item_sctp)),
1321                 .next = NEXT(item_sctp),
1322                 .call = parse_vc,
1323         },
1324         [ITEM_SCTP_SRC] = {
1325                 .name = "src",
1326                 .help = "SCTP source port",
1327                 .next = NEXT(item_sctp, NEXT_ENTRY(UNSIGNED), item_param),
1328                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_sctp,
1329                                              hdr.src_port)),
1330         },
1331         [ITEM_SCTP_DST] = {
1332                 .name = "dst",
1333                 .help = "SCTP destination port",
1334                 .next = NEXT(item_sctp, NEXT_ENTRY(UNSIGNED), item_param),
1335                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_sctp,
1336                                              hdr.dst_port)),
1337         },
1338         [ITEM_SCTP_TAG] = {
1339                 .name = "tag",
1340                 .help = "validation tag",
1341                 .next = NEXT(item_sctp, NEXT_ENTRY(UNSIGNED), item_param),
1342                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_sctp,
1343                                              hdr.tag)),
1344         },
1345         [ITEM_SCTP_CKSUM] = {
1346                 .name = "cksum",
1347                 .help = "checksum",
1348                 .next = NEXT(item_sctp, NEXT_ENTRY(UNSIGNED), item_param),
1349                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_sctp,
1350                                              hdr.cksum)),
1351         },
1352         [ITEM_VXLAN] = {
1353                 .name = "vxlan",
1354                 .help = "match VXLAN header",
1355                 .priv = PRIV_ITEM(VXLAN, sizeof(struct rte_flow_item_vxlan)),
1356                 .next = NEXT(item_vxlan),
1357                 .call = parse_vc,
1358         },
1359         [ITEM_VXLAN_VNI] = {
1360                 .name = "vni",
1361                 .help = "VXLAN identifier",
1362                 .next = NEXT(item_vxlan, NEXT_ENTRY(UNSIGNED), item_param),
1363                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_vxlan, vni)),
1364         },
1365         [ITEM_E_TAG] = {
1366                 .name = "e_tag",
1367                 .help = "match E-Tag header",
1368                 .priv = PRIV_ITEM(E_TAG, sizeof(struct rte_flow_item_e_tag)),
1369                 .next = NEXT(item_e_tag),
1370                 .call = parse_vc,
1371         },
1372         [ITEM_E_TAG_GRP_ECID_B] = {
1373                 .name = "grp_ecid_b",
1374                 .help = "GRP and E-CID base",
1375                 .next = NEXT(item_e_tag, NEXT_ENTRY(UNSIGNED), item_param),
1376                 .args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_e_tag,
1377                                                   rsvd_grp_ecid_b,
1378                                                   "\x3f\xff")),
1379         },
1380         [ITEM_NVGRE] = {
1381                 .name = "nvgre",
1382                 .help = "match NVGRE header",
1383                 .priv = PRIV_ITEM(NVGRE, sizeof(struct rte_flow_item_nvgre)),
1384                 .next = NEXT(item_nvgre),
1385                 .call = parse_vc,
1386         },
1387         [ITEM_NVGRE_TNI] = {
1388                 .name = "tni",
1389                 .help = "virtual subnet ID",
1390                 .next = NEXT(item_nvgre, NEXT_ENTRY(UNSIGNED), item_param),
1391                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_nvgre, tni)),
1392         },
1393         [ITEM_MPLS] = {
1394                 .name = "mpls",
1395                 .help = "match MPLS header",
1396                 .priv = PRIV_ITEM(MPLS, sizeof(struct rte_flow_item_mpls)),
1397                 .next = NEXT(item_mpls),
1398                 .call = parse_vc,
1399         },
1400         [ITEM_MPLS_LABEL] = {
1401                 .name = "label",
1402                 .help = "MPLS label",
1403                 .next = NEXT(item_mpls, NEXT_ENTRY(UNSIGNED), item_param),
1404                 .args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_mpls,
1405                                                   label_tc_s,
1406                                                   "\xff\xff\xf0")),
1407         },
1408         [ITEM_GRE] = {
1409                 .name = "gre",
1410                 .help = "match GRE header",
1411                 .priv = PRIV_ITEM(GRE, sizeof(struct rte_flow_item_gre)),
1412                 .next = NEXT(item_gre),
1413                 .call = parse_vc,
1414         },
1415         [ITEM_GRE_PROTO] = {
1416                 .name = "protocol",
1417                 .help = "GRE protocol type",
1418                 .next = NEXT(item_gre, NEXT_ENTRY(UNSIGNED), item_param),
1419                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_gre,
1420                                              protocol)),
1421         },
1422         [ITEM_FUZZY] = {
1423                 .name = "fuzzy",
1424                 .help = "fuzzy pattern match, expect faster than default",
1425                 .priv = PRIV_ITEM(FUZZY,
1426                                 sizeof(struct rte_flow_item_fuzzy)),
1427                 .next = NEXT(item_fuzzy),
1428                 .call = parse_vc,
1429         },
1430         [ITEM_FUZZY_THRESH] = {
1431                 .name = "thresh",
1432                 .help = "match accuracy threshold",
1433                 .next = NEXT(item_fuzzy, NEXT_ENTRY(UNSIGNED), item_param),
1434                 .args = ARGS(ARGS_ENTRY(struct rte_flow_item_fuzzy,
1435                                         thresh)),
1436         },
1437         [ITEM_GTP] = {
1438                 .name = "gtp",
1439                 .help = "match GTP header",
1440                 .priv = PRIV_ITEM(GTP, sizeof(struct rte_flow_item_gtp)),
1441                 .next = NEXT(item_gtp),
1442                 .call = parse_vc,
1443         },
1444         [ITEM_GTP_TEID] = {
1445                 .name = "teid",
1446                 .help = "tunnel endpoint identifier",
1447                 .next = NEXT(item_gtp, NEXT_ENTRY(UNSIGNED), item_param),
1448                 .args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_gtp, teid)),
1449         },
1450         [ITEM_GTPC] = {
1451                 .name = "gtpc",
1452                 .help = "match GTP header",
1453                 .priv = PRIV_ITEM(GTPC, sizeof(struct rte_flow_item_gtp)),
1454                 .next = NEXT(item_gtp),
1455                 .call = parse_vc,
1456         },
1457         [ITEM_GTPU] = {
1458                 .name = "gtpu",
1459                 .help = "match GTP header",
1460                 .priv = PRIV_ITEM(GTPU, sizeof(struct rte_flow_item_gtp)),
1461                 .next = NEXT(item_gtp),
1462                 .call = parse_vc,
1463         },
1464
1465         /* Validate/create actions. */
1466         [ACTIONS] = {
1467                 .name = "actions",
1468                 .help = "submit a list of associated actions",
1469                 .next = NEXT(next_action),
1470                 .call = parse_vc,
1471         },
1472         [ACTION_NEXT] = {
1473                 .name = "/",
1474                 .help = "specify next action",
1475                 .next = NEXT(next_action),
1476         },
1477         [ACTION_END] = {
1478                 .name = "end",
1479                 .help = "end list of actions",
1480                 .priv = PRIV_ACTION(END, 0),
1481                 .call = parse_vc,
1482         },
1483         [ACTION_VOID] = {
1484                 .name = "void",
1485                 .help = "no-op action",
1486                 .priv = PRIV_ACTION(VOID, 0),
1487                 .next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
1488                 .call = parse_vc,
1489         },
1490         [ACTION_PASSTHRU] = {
1491                 .name = "passthru",
1492                 .help = "let subsequent rule process matched packets",
1493                 .priv = PRIV_ACTION(PASSTHRU, 0),
1494                 .next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
1495                 .call = parse_vc,
1496         },
1497         [ACTION_MARK] = {
1498                 .name = "mark",
1499                 .help = "attach 32 bit value to packets",
1500                 .priv = PRIV_ACTION(MARK, sizeof(struct rte_flow_action_mark)),
1501                 .next = NEXT(action_mark),
1502                 .call = parse_vc,
1503         },
1504         [ACTION_MARK_ID] = {
1505                 .name = "id",
1506                 .help = "32 bit value to return with packets",
1507                 .next = NEXT(action_mark, NEXT_ENTRY(UNSIGNED)),
1508                 .args = ARGS(ARGS_ENTRY(struct rte_flow_action_mark, id)),
1509                 .call = parse_vc_conf,
1510         },
1511         [ACTION_FLAG] = {
1512                 .name = "flag",
1513                 .help = "flag packets",
1514                 .priv = PRIV_ACTION(FLAG, 0),
1515                 .next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
1516                 .call = parse_vc,
1517         },
1518         [ACTION_QUEUE] = {
1519                 .name = "queue",
1520                 .help = "assign packets to a given queue index",
1521                 .priv = PRIV_ACTION(QUEUE,
1522                                     sizeof(struct rte_flow_action_queue)),
1523                 .next = NEXT(action_queue),
1524                 .call = parse_vc,
1525         },
1526         [ACTION_QUEUE_INDEX] = {
1527                 .name = "index",
1528                 .help = "queue index to use",
1529                 .next = NEXT(action_queue, NEXT_ENTRY(UNSIGNED)),
1530                 .args = ARGS(ARGS_ENTRY(struct rte_flow_action_queue, index)),
1531                 .call = parse_vc_conf,
1532         },
1533         [ACTION_DROP] = {
1534                 .name = "drop",
1535                 .help = "drop packets (note: passthru has priority)",
1536                 .priv = PRIV_ACTION(DROP, 0),
1537                 .next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
1538                 .call = parse_vc,
1539         },
1540         [ACTION_COUNT] = {
1541                 .name = "count",
1542                 .help = "enable counters for this rule",
1543                 .priv = PRIV_ACTION(COUNT, 0),
1544                 .next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
1545                 .call = parse_vc,
1546         },
1547         [ACTION_DUP] = {
1548                 .name = "dup",
1549                 .help = "duplicate packets to a given queue index",
1550                 .priv = PRIV_ACTION(DUP, sizeof(struct rte_flow_action_dup)),
1551                 .next = NEXT(action_dup),
1552                 .call = parse_vc,
1553         },
1554         [ACTION_DUP_INDEX] = {
1555                 .name = "index",
1556                 .help = "queue index to duplicate packets to",
1557                 .next = NEXT(action_dup, NEXT_ENTRY(UNSIGNED)),
1558                 .args = ARGS(ARGS_ENTRY(struct rte_flow_action_dup, index)),
1559                 .call = parse_vc_conf,
1560         },
1561         [ACTION_RSS] = {
1562                 .name = "rss",
1563                 .help = "spread packets among several queues",
1564                 .priv = PRIV_ACTION(RSS, ACTION_RSS_SIZE),
1565                 .next = NEXT(action_rss),
1566                 .call = parse_vc,
1567         },
1568         [ACTION_RSS_QUEUES] = {
1569                 .name = "queues",
1570                 .help = "queue indices to use",
1571                 .next = NEXT(action_rss, NEXT_ENTRY(ACTION_RSS_QUEUE)),
1572                 .call = parse_vc_conf,
1573         },
1574         [ACTION_RSS_QUEUE] = {
1575                 .name = "{queue}",
1576                 .help = "queue index",
1577                 .call = parse_vc_action_rss_queue,
1578                 .comp = comp_vc_action_rss_queue,
1579         },
1580         [ACTION_PF] = {
1581                 .name = "pf",
1582                 .help = "redirect packets to physical device function",
1583                 .priv = PRIV_ACTION(PF, 0),
1584                 .next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
1585                 .call = parse_vc,
1586         },
1587         [ACTION_VF] = {
1588                 .name = "vf",
1589                 .help = "redirect packets to virtual device function",
1590                 .priv = PRIV_ACTION(VF, sizeof(struct rte_flow_action_vf)),
1591                 .next = NEXT(action_vf),
1592                 .call = parse_vc,
1593         },
1594         [ACTION_VF_ORIGINAL] = {
1595                 .name = "original",
1596                 .help = "use original VF ID if possible",
1597                 .next = NEXT(action_vf, NEXT_ENTRY(BOOLEAN)),
1598                 .args = ARGS(ARGS_ENTRY_BF(struct rte_flow_action_vf,
1599                                            original, 1)),
1600                 .call = parse_vc_conf,
1601         },
1602         [ACTION_VF_ID] = {
1603                 .name = "id",
1604                 .help = "VF ID to redirect packets to",
1605                 .next = NEXT(action_vf, NEXT_ENTRY(UNSIGNED)),
1606                 .args = ARGS(ARGS_ENTRY(struct rte_flow_action_vf, id)),
1607                 .call = parse_vc_conf,
1608         },
1609 };
1610
1611 /** Remove and return last entry from argument stack. */
1612 static const struct arg *
1613 pop_args(struct context *ctx)
1614 {
1615         return ctx->args_num ? ctx->args[--ctx->args_num] : NULL;
1616 }
1617
1618 /** Add entry on top of the argument stack. */
1619 static int
1620 push_args(struct context *ctx, const struct arg *arg)
1621 {
1622         if (ctx->args_num == CTX_STACK_SIZE)
1623                 return -1;
1624         ctx->args[ctx->args_num++] = arg;
1625         return 0;
1626 }
1627
1628 /** Spread value into buffer according to bit-mask. */
1629 static size_t
1630 arg_entry_bf_fill(void *dst, uintmax_t val, const struct arg *arg)
1631 {
1632         uint32_t i = arg->size;
1633         uint32_t end = 0;
1634         int sub = 1;
1635         int add = 0;
1636         size_t len = 0;
1637
1638         if (!arg->mask)
1639                 return 0;
1640 #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
1641         if (!arg->hton) {
1642                 i = 0;
1643                 end = arg->size;
1644                 sub = 0;
1645                 add = 1;
1646         }
1647 #endif
1648         while (i != end) {
1649                 unsigned int shift = 0;
1650                 uint8_t *buf = (uint8_t *)dst + arg->offset + (i -= sub);
1651
1652                 for (shift = 0; arg->mask[i] >> shift; ++shift) {
1653                         if (!(arg->mask[i] & (1 << shift)))
1654                                 continue;
1655                         ++len;
1656                         if (!dst)
1657                                 continue;
1658                         *buf &= ~(1 << shift);
1659                         *buf |= (val & 1) << shift;
1660                         val >>= 1;
1661                 }
1662                 i += add;
1663         }
1664         return len;
1665 }
1666
1667 /** Compare a string with a partial one of a given length. */
1668 static int
1669 strcmp_partial(const char *full, const char *partial, size_t partial_len)
1670 {
1671         int r = strncmp(full, partial, partial_len);
1672
1673         if (r)
1674                 return r;
1675         if (strlen(full) <= partial_len)
1676                 return 0;
1677         return full[partial_len];
1678 }
1679
1680 /**
1681  * Parse a prefix length and generate a bit-mask.
1682  *
1683  * Last argument (ctx->args) is retrieved to determine mask size, storage
1684  * location and whether the result must use network byte ordering.
1685  */
1686 static int
1687 parse_prefix(struct context *ctx, const struct token *token,
1688              const char *str, unsigned int len,
1689              void *buf, unsigned int size)
1690 {
1691         const struct arg *arg = pop_args(ctx);
1692         static const uint8_t conv[] = "\x00\x80\xc0\xe0\xf0\xf8\xfc\xfe\xff";
1693         char *end;
1694         uintmax_t u;
1695         unsigned int bytes;
1696         unsigned int extra;
1697
1698         (void)token;
1699         /* Argument is expected. */
1700         if (!arg)
1701                 return -1;
1702         errno = 0;
1703         u = strtoumax(str, &end, 0);
1704         if (errno || (size_t)(end - str) != len)
1705                 goto error;
1706         if (arg->mask) {
1707                 uintmax_t v = 0;
1708
1709                 extra = arg_entry_bf_fill(NULL, 0, arg);
1710                 if (u > extra)
1711                         goto error;
1712                 if (!ctx->object)
1713                         return len;
1714                 extra -= u;
1715                 while (u--)
1716                         (v <<= 1, v |= 1);
1717                 v <<= extra;
1718                 if (!arg_entry_bf_fill(ctx->object, v, arg) ||
1719                     !arg_entry_bf_fill(ctx->objmask, -1, arg))
1720                         goto error;
1721                 return len;
1722         }
1723         bytes = u / 8;
1724         extra = u % 8;
1725         size = arg->size;
1726         if (bytes > size || bytes + !!extra > size)
1727                 goto error;
1728         if (!ctx->object)
1729                 return len;
1730         buf = (uint8_t *)ctx->object + arg->offset;
1731 #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
1732         if (!arg->hton) {
1733                 memset((uint8_t *)buf + size - bytes, 0xff, bytes);
1734                 memset(buf, 0x00, size - bytes);
1735                 if (extra)
1736                         ((uint8_t *)buf)[size - bytes - 1] = conv[extra];
1737         } else
1738 #endif
1739         {
1740                 memset(buf, 0xff, bytes);
1741                 memset((uint8_t *)buf + bytes, 0x00, size - bytes);
1742                 if (extra)
1743                         ((uint8_t *)buf)[bytes] = conv[extra];
1744         }
1745         if (ctx->objmask)
1746                 memset((uint8_t *)ctx->objmask + arg->offset, 0xff, size);
1747         return len;
1748 error:
1749         push_args(ctx, arg);
1750         return -1;
1751 }
1752
1753 /** Default parsing function for token name matching. */
1754 static int
1755 parse_default(struct context *ctx, const struct token *token,
1756               const char *str, unsigned int len,
1757               void *buf, unsigned int size)
1758 {
1759         (void)ctx;
1760         (void)buf;
1761         (void)size;
1762         if (strcmp_partial(token->name, str, len))
1763                 return -1;
1764         return len;
1765 }
1766
1767 /** Parse flow command, initialize output buffer for subsequent tokens. */
1768 static int
1769 parse_init(struct context *ctx, const struct token *token,
1770            const char *str, unsigned int len,
1771            void *buf, unsigned int size)
1772 {
1773         struct buffer *out = buf;
1774
1775         /* Token name must match. */
1776         if (parse_default(ctx, token, str, len, NULL, 0) < 0)
1777                 return -1;
1778         /* Nothing else to do if there is no buffer. */
1779         if (!out)
1780                 return len;
1781         /* Make sure buffer is large enough. */
1782         if (size < sizeof(*out))
1783                 return -1;
1784         /* Initialize buffer. */
1785         memset(out, 0x00, sizeof(*out));
1786         memset((uint8_t *)out + sizeof(*out), 0x22, size - sizeof(*out));
1787         ctx->objdata = 0;
1788         ctx->object = out;
1789         ctx->objmask = NULL;
1790         return len;
1791 }
1792
1793 /** Parse tokens for validate/create commands. */
1794 static int
1795 parse_vc(struct context *ctx, const struct token *token,
1796          const char *str, unsigned int len,
1797          void *buf, unsigned int size)
1798 {
1799         struct buffer *out = buf;
1800         uint8_t *data;
1801         uint32_t data_size;
1802
1803         /* Token name must match. */
1804         if (parse_default(ctx, token, str, len, NULL, 0) < 0)
1805                 return -1;
1806         /* Nothing else to do if there is no buffer. */
1807         if (!out)
1808                 return len;
1809         if (!out->command) {
1810                 if (ctx->curr != VALIDATE && ctx->curr != CREATE)
1811                         return -1;
1812                 if (sizeof(*out) > size)
1813                         return -1;
1814                 out->command = ctx->curr;
1815                 ctx->objdata = 0;
1816                 ctx->object = out;
1817                 ctx->objmask = NULL;
1818                 out->args.vc.data = (uint8_t *)out + size;
1819                 return len;
1820         }
1821         ctx->objdata = 0;
1822         ctx->object = &out->args.vc.attr;
1823         ctx->objmask = NULL;
1824         switch (ctx->curr) {
1825         case GROUP:
1826         case PRIORITY:
1827                 return len;
1828         case INGRESS:
1829                 out->args.vc.attr.ingress = 1;
1830                 return len;
1831         case EGRESS:
1832                 out->args.vc.attr.egress = 1;
1833                 return len;
1834         case PATTERN:
1835                 out->args.vc.pattern =
1836                         (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
1837                                                sizeof(double));
1838                 ctx->object = out->args.vc.pattern;
1839                 ctx->objmask = NULL;
1840                 return len;
1841         case ACTIONS:
1842                 out->args.vc.actions =
1843                         (void *)RTE_ALIGN_CEIL((uintptr_t)
1844                                                (out->args.vc.pattern +
1845                                                 out->args.vc.pattern_n),
1846                                                sizeof(double));
1847                 ctx->object = out->args.vc.actions;
1848                 ctx->objmask = NULL;
1849                 return len;
1850         default:
1851                 if (!token->priv)
1852                         return -1;
1853                 break;
1854         }
1855         if (!out->args.vc.actions) {
1856                 const struct parse_item_priv *priv = token->priv;
1857                 struct rte_flow_item *item =
1858                         out->args.vc.pattern + out->args.vc.pattern_n;
1859
1860                 data_size = priv->size * 3; /* spec, last, mask */
1861                 data = (void *)RTE_ALIGN_FLOOR((uintptr_t)
1862                                                (out->args.vc.data - data_size),
1863                                                sizeof(double));
1864                 if ((uint8_t *)item + sizeof(*item) > data)
1865                         return -1;
1866                 *item = (struct rte_flow_item){
1867                         .type = priv->type,
1868                 };
1869                 ++out->args.vc.pattern_n;
1870                 ctx->object = item;
1871                 ctx->objmask = NULL;
1872         } else {
1873                 const struct parse_action_priv *priv = token->priv;
1874                 struct rte_flow_action *action =
1875                         out->args.vc.actions + out->args.vc.actions_n;
1876
1877                 data_size = priv->size; /* configuration */
1878                 data = (void *)RTE_ALIGN_FLOOR((uintptr_t)
1879                                                (out->args.vc.data - data_size),
1880                                                sizeof(double));
1881                 if ((uint8_t *)action + sizeof(*action) > data)
1882                         return -1;
1883                 *action = (struct rte_flow_action){
1884                         .type = priv->type,
1885                 };
1886                 ++out->args.vc.actions_n;
1887                 ctx->object = action;
1888                 ctx->objmask = NULL;
1889         }
1890         memset(data, 0, data_size);
1891         out->args.vc.data = data;
1892         ctx->objdata = data_size;
1893         return len;
1894 }
1895
1896 /** Parse pattern item parameter type. */
1897 static int
1898 parse_vc_spec(struct context *ctx, const struct token *token,
1899               const char *str, unsigned int len,
1900               void *buf, unsigned int size)
1901 {
1902         struct buffer *out = buf;
1903         struct rte_flow_item *item;
1904         uint32_t data_size;
1905         int index;
1906         int objmask = 0;
1907
1908         (void)size;
1909         /* Token name must match. */
1910         if (parse_default(ctx, token, str, len, NULL, 0) < 0)
1911                 return -1;
1912         /* Parse parameter types. */
1913         switch (ctx->curr) {
1914                 static const enum index prefix[] = NEXT_ENTRY(PREFIX);
1915
1916         case ITEM_PARAM_IS:
1917                 index = 0;
1918                 objmask = 1;
1919                 break;
1920         case ITEM_PARAM_SPEC:
1921                 index = 0;
1922                 break;
1923         case ITEM_PARAM_LAST:
1924                 index = 1;
1925                 break;
1926         case ITEM_PARAM_PREFIX:
1927                 /* Modify next token to expect a prefix. */
1928                 if (ctx->next_num < 2)
1929                         return -1;
1930                 ctx->next[ctx->next_num - 2] = prefix;
1931                 /* Fall through. */
1932         case ITEM_PARAM_MASK:
1933                 index = 2;
1934                 break;
1935         default:
1936                 return -1;
1937         }
1938         /* Nothing else to do if there is no buffer. */
1939         if (!out)
1940                 return len;
1941         if (!out->args.vc.pattern_n)
1942                 return -1;
1943         item = &out->args.vc.pattern[out->args.vc.pattern_n - 1];
1944         data_size = ctx->objdata / 3; /* spec, last, mask */
1945         /* Point to selected object. */
1946         ctx->object = out->args.vc.data + (data_size * index);
1947         if (objmask) {
1948                 ctx->objmask = out->args.vc.data + (data_size * 2); /* mask */
1949                 item->mask = ctx->objmask;
1950         } else
1951                 ctx->objmask = NULL;
1952         /* Update relevant item pointer. */
1953         *((const void **[]){ &item->spec, &item->last, &item->mask })[index] =
1954                 ctx->object;
1955         return len;
1956 }
1957
1958 /** Parse action configuration field. */
1959 static int
1960 parse_vc_conf(struct context *ctx, const struct token *token,
1961               const char *str, unsigned int len,
1962               void *buf, unsigned int size)
1963 {
1964         struct buffer *out = buf;
1965         struct rte_flow_action *action;
1966
1967         (void)size;
1968         /* Token name must match. */
1969         if (parse_default(ctx, token, str, len, NULL, 0) < 0)
1970                 return -1;
1971         /* Nothing else to do if there is no buffer. */
1972         if (!out)
1973                 return len;
1974         if (!out->args.vc.actions_n)
1975                 return -1;
1976         action = &out->args.vc.actions[out->args.vc.actions_n - 1];
1977         /* Point to selected object. */
1978         ctx->object = out->args.vc.data;
1979         ctx->objmask = NULL;
1980         /* Update configuration pointer. */
1981         action->conf = ctx->object;
1982         return len;
1983 }
1984
1985 /**
1986  * Parse queue field for RSS action.
1987  *
1988  * Valid tokens are queue indices and the "end" token.
1989  */
1990 static int
1991 parse_vc_action_rss_queue(struct context *ctx, const struct token *token,
1992                           const char *str, unsigned int len,
1993                           void *buf, unsigned int size)
1994 {
1995         static const enum index next[] = NEXT_ENTRY(ACTION_RSS_QUEUE);
1996         int ret;
1997         int i;
1998
1999         (void)token;
2000         (void)buf;
2001         (void)size;
2002         if (ctx->curr != ACTION_RSS_QUEUE)
2003                 return -1;
2004         i = ctx->objdata >> 16;
2005         if (!strcmp_partial("end", str, len)) {
2006                 ctx->objdata &= 0xffff;
2007                 return len;
2008         }
2009         if (i >= ACTION_RSS_NUM)
2010                 return -1;
2011         if (push_args(ctx, ARGS_ENTRY(struct rte_flow_action_rss, queue[i])))
2012                 return -1;
2013         ret = parse_int(ctx, token, str, len, NULL, 0);
2014         if (ret < 0) {
2015                 pop_args(ctx);
2016                 return -1;
2017         }
2018         ++i;
2019         ctx->objdata = i << 16 | (ctx->objdata & 0xffff);
2020         /* Repeat token. */
2021         if (ctx->next_num == RTE_DIM(ctx->next))
2022                 return -1;
2023         ctx->next[ctx->next_num++] = next;
2024         if (!ctx->object)
2025                 return len;
2026         ((struct rte_flow_action_rss *)ctx->object)->num = i;
2027         return len;
2028 }
2029
2030 /** Parse tokens for destroy command. */
2031 static int
2032 parse_destroy(struct context *ctx, const struct token *token,
2033               const char *str, unsigned int len,
2034               void *buf, unsigned int size)
2035 {
2036         struct buffer *out = buf;
2037
2038         /* Token name must match. */
2039         if (parse_default(ctx, token, str, len, NULL, 0) < 0)
2040                 return -1;
2041         /* Nothing else to do if there is no buffer. */
2042         if (!out)
2043                 return len;
2044         if (!out->command) {
2045                 if (ctx->curr != DESTROY)
2046                         return -1;
2047                 if (sizeof(*out) > size)
2048                         return -1;
2049                 out->command = ctx->curr;
2050                 ctx->objdata = 0;
2051                 ctx->object = out;
2052                 ctx->objmask = NULL;
2053                 out->args.destroy.rule =
2054                         (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
2055                                                sizeof(double));
2056                 return len;
2057         }
2058         if (((uint8_t *)(out->args.destroy.rule + out->args.destroy.rule_n) +
2059              sizeof(*out->args.destroy.rule)) > (uint8_t *)out + size)
2060                 return -1;
2061         ctx->objdata = 0;
2062         ctx->object = out->args.destroy.rule + out->args.destroy.rule_n++;
2063         ctx->objmask = NULL;
2064         return len;
2065 }
2066
2067 /** Parse tokens for flush command. */
2068 static int
2069 parse_flush(struct context *ctx, const struct token *token,
2070             const char *str, unsigned int len,
2071             void *buf, unsigned int size)
2072 {
2073         struct buffer *out = buf;
2074
2075         /* Token name must match. */
2076         if (parse_default(ctx, token, str, len, NULL, 0) < 0)
2077                 return -1;
2078         /* Nothing else to do if there is no buffer. */
2079         if (!out)
2080                 return len;
2081         if (!out->command) {
2082                 if (ctx->curr != FLUSH)
2083                         return -1;
2084                 if (sizeof(*out) > size)
2085                         return -1;
2086                 out->command = ctx->curr;
2087                 ctx->objdata = 0;
2088                 ctx->object = out;
2089                 ctx->objmask = NULL;
2090         }
2091         return len;
2092 }
2093
2094 /** Parse tokens for query command. */
2095 static int
2096 parse_query(struct context *ctx, const struct token *token,
2097             const char *str, unsigned int len,
2098             void *buf, unsigned int size)
2099 {
2100         struct buffer *out = buf;
2101
2102         /* Token name must match. */
2103         if (parse_default(ctx, token, str, len, NULL, 0) < 0)
2104                 return -1;
2105         /* Nothing else to do if there is no buffer. */
2106         if (!out)
2107                 return len;
2108         if (!out->command) {
2109                 if (ctx->curr != QUERY)
2110                         return -1;
2111                 if (sizeof(*out) > size)
2112                         return -1;
2113                 out->command = ctx->curr;
2114                 ctx->objdata = 0;
2115                 ctx->object = out;
2116                 ctx->objmask = NULL;
2117         }
2118         return len;
2119 }
2120
2121 /** Parse action names. */
2122 static int
2123 parse_action(struct context *ctx, const struct token *token,
2124              const char *str, unsigned int len,
2125              void *buf, unsigned int size)
2126 {
2127         struct buffer *out = buf;
2128         const struct arg *arg = pop_args(ctx);
2129         unsigned int i;
2130
2131         (void)size;
2132         /* Argument is expected. */
2133         if (!arg)
2134                 return -1;
2135         /* Parse action name. */
2136         for (i = 0; next_action[i]; ++i) {
2137                 const struct parse_action_priv *priv;
2138
2139                 token = &token_list[next_action[i]];
2140                 if (strcmp_partial(token->name, str, len))
2141                         continue;
2142                 priv = token->priv;
2143                 if (!priv)
2144                         goto error;
2145                 if (out)
2146                         memcpy((uint8_t *)ctx->object + arg->offset,
2147                                &priv->type,
2148                                arg->size);
2149                 return len;
2150         }
2151 error:
2152         push_args(ctx, arg);
2153         return -1;
2154 }
2155
2156 /** Parse tokens for list command. */
2157 static int
2158 parse_list(struct context *ctx, const struct token *token,
2159            const char *str, unsigned int len,
2160            void *buf, unsigned int size)
2161 {
2162         struct buffer *out = buf;
2163
2164         /* Token name must match. */
2165         if (parse_default(ctx, token, str, len, NULL, 0) < 0)
2166                 return -1;
2167         /* Nothing else to do if there is no buffer. */
2168         if (!out)
2169                 return len;
2170         if (!out->command) {
2171                 if (ctx->curr != LIST)
2172                         return -1;
2173                 if (sizeof(*out) > size)
2174                         return -1;
2175                 out->command = ctx->curr;
2176                 ctx->objdata = 0;
2177                 ctx->object = out;
2178                 ctx->objmask = NULL;
2179                 out->args.list.group =
2180                         (void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
2181                                                sizeof(double));
2182                 return len;
2183         }
2184         if (((uint8_t *)(out->args.list.group + out->args.list.group_n) +
2185              sizeof(*out->args.list.group)) > (uint8_t *)out + size)
2186                 return -1;
2187         ctx->objdata = 0;
2188         ctx->object = out->args.list.group + out->args.list.group_n++;
2189         ctx->objmask = NULL;
2190         return len;
2191 }
2192
2193 /** Parse tokens for isolate command. */
2194 static int
2195 parse_isolate(struct context *ctx, const struct token *token,
2196               const char *str, unsigned int len,
2197               void *buf, unsigned int size)
2198 {
2199         struct buffer *out = buf;
2200
2201         /* Token name must match. */
2202         if (parse_default(ctx, token, str, len, NULL, 0) < 0)
2203                 return -1;
2204         /* Nothing else to do if there is no buffer. */
2205         if (!out)
2206                 return len;
2207         if (!out->command) {
2208                 if (ctx->curr != ISOLATE)
2209                         return -1;
2210                 if (sizeof(*out) > size)
2211                         return -1;
2212                 out->command = ctx->curr;
2213                 ctx->objdata = 0;
2214                 ctx->object = out;
2215                 ctx->objmask = NULL;
2216         }
2217         return len;
2218 }
2219
2220 /**
2221  * Parse signed/unsigned integers 8 to 64-bit long.
2222  *
2223  * Last argument (ctx->args) is retrieved to determine integer type and
2224  * storage location.
2225  */
2226 static int
2227 parse_int(struct context *ctx, const struct token *token,
2228           const char *str, unsigned int len,
2229           void *buf, unsigned int size)
2230 {
2231         const struct arg *arg = pop_args(ctx);
2232         uintmax_t u;
2233         char *end;
2234
2235         (void)token;
2236         /* Argument is expected. */
2237         if (!arg)
2238                 return -1;
2239         errno = 0;
2240         u = arg->sign ?
2241                 (uintmax_t)strtoimax(str, &end, 0) :
2242                 strtoumax(str, &end, 0);
2243         if (errno || (size_t)(end - str) != len)
2244                 goto error;
2245         if (!ctx->object)
2246                 return len;
2247         if (arg->mask) {
2248                 if (!arg_entry_bf_fill(ctx->object, u, arg) ||
2249                     !arg_entry_bf_fill(ctx->objmask, -1, arg))
2250                         goto error;
2251                 return len;
2252         }
2253         buf = (uint8_t *)ctx->object + arg->offset;
2254         size = arg->size;
2255 objmask:
2256         switch (size) {
2257         case sizeof(uint8_t):
2258                 *(uint8_t *)buf = u;
2259                 break;
2260         case sizeof(uint16_t):
2261                 *(uint16_t *)buf = arg->hton ? rte_cpu_to_be_16(u) : u;
2262                 break;
2263         case sizeof(uint8_t [3]):
2264 #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
2265                 if (!arg->hton) {
2266                         ((uint8_t *)buf)[0] = u;
2267                         ((uint8_t *)buf)[1] = u >> 8;
2268                         ((uint8_t *)buf)[2] = u >> 16;
2269                         break;
2270                 }
2271 #endif
2272                 ((uint8_t *)buf)[0] = u >> 16;
2273                 ((uint8_t *)buf)[1] = u >> 8;
2274                 ((uint8_t *)buf)[2] = u;
2275                 break;
2276         case sizeof(uint32_t):
2277                 *(uint32_t *)buf = arg->hton ? rte_cpu_to_be_32(u) : u;
2278                 break;
2279         case sizeof(uint64_t):
2280                 *(uint64_t *)buf = arg->hton ? rte_cpu_to_be_64(u) : u;
2281                 break;
2282         default:
2283                 goto error;
2284         }
2285         if (ctx->objmask && buf != (uint8_t *)ctx->objmask + arg->offset) {
2286                 u = -1;
2287                 buf = (uint8_t *)ctx->objmask + arg->offset;
2288                 goto objmask;
2289         }
2290         return len;
2291 error:
2292         push_args(ctx, arg);
2293         return -1;
2294 }
2295
2296 /**
2297  * Parse a string.
2298  *
2299  * Two arguments (ctx->args) are retrieved from the stack to store data and
2300  * its length (in that order).
2301  */
2302 static int
2303 parse_string(struct context *ctx, const struct token *token,
2304              const char *str, unsigned int len,
2305              void *buf, unsigned int size)
2306 {
2307         const struct arg *arg_data = pop_args(ctx);
2308         const struct arg *arg_len = pop_args(ctx);
2309         char tmp[16]; /* Ought to be enough. */
2310         int ret;
2311
2312         /* Arguments are expected. */
2313         if (!arg_data)
2314                 return -1;
2315         if (!arg_len) {
2316                 push_args(ctx, arg_data);
2317                 return -1;
2318         }
2319         size = arg_data->size;
2320         /* Bit-mask fill is not supported. */
2321         if (arg_data->mask || size < len)
2322                 goto error;
2323         if (!ctx->object)
2324                 return len;
2325         /* Let parse_int() fill length information first. */
2326         ret = snprintf(tmp, sizeof(tmp), "%u", len);
2327         if (ret < 0)
2328                 goto error;
2329         push_args(ctx, arg_len);
2330         ret = parse_int(ctx, token, tmp, ret, NULL, 0);
2331         if (ret < 0) {
2332                 pop_args(ctx);
2333                 goto error;
2334         }
2335         buf = (uint8_t *)ctx->object + arg_data->offset;
2336         /* Output buffer is not necessarily NUL-terminated. */
2337         memcpy(buf, str, len);
2338         memset((uint8_t *)buf + len, 0x55, size - len);
2339         if (ctx->objmask)
2340                 memset((uint8_t *)ctx->objmask + arg_data->offset, 0xff, len);
2341         return len;
2342 error:
2343         push_args(ctx, arg_len);
2344         push_args(ctx, arg_data);
2345         return -1;
2346 }
2347
2348 /**
2349  * Parse a MAC address.
2350  *
2351  * Last argument (ctx->args) is retrieved to determine storage size and
2352  * location.
2353  */
2354 static int
2355 parse_mac_addr(struct context *ctx, const struct token *token,
2356                const char *str, unsigned int len,
2357                void *buf, unsigned int size)
2358 {
2359         const struct arg *arg = pop_args(ctx);
2360         struct ether_addr tmp;
2361         int ret;
2362
2363         (void)token;
2364         /* Argument is expected. */
2365         if (!arg)
2366                 return -1;
2367         size = arg->size;
2368         /* Bit-mask fill is not supported. */
2369         if (arg->mask || size != sizeof(tmp))
2370                 goto error;
2371         /* Only network endian is supported. */
2372         if (!arg->hton)
2373                 goto error;
2374         ret = cmdline_parse_etheraddr(NULL, str, &tmp, size);
2375         if (ret < 0 || (unsigned int)ret != len)
2376                 goto error;
2377         if (!ctx->object)
2378                 return len;
2379         buf = (uint8_t *)ctx->object + arg->offset;
2380         memcpy(buf, &tmp, size);
2381         if (ctx->objmask)
2382                 memset((uint8_t *)ctx->objmask + arg->offset, 0xff, size);
2383         return len;
2384 error:
2385         push_args(ctx, arg);
2386         return -1;
2387 }
2388
2389 /**
2390  * Parse an IPv4 address.
2391  *
2392  * Last argument (ctx->args) is retrieved to determine storage size and
2393  * location.
2394  */
2395 static int
2396 parse_ipv4_addr(struct context *ctx, const struct token *token,
2397                 const char *str, unsigned int len,
2398                 void *buf, unsigned int size)
2399 {
2400         const struct arg *arg = pop_args(ctx);
2401         char str2[len + 1];
2402         struct in_addr tmp;
2403         int ret;
2404
2405         /* Argument is expected. */
2406         if (!arg)
2407                 return -1;
2408         size = arg->size;
2409         /* Bit-mask fill is not supported. */
2410         if (arg->mask || size != sizeof(tmp))
2411                 goto error;
2412         /* Only network endian is supported. */
2413         if (!arg->hton)
2414                 goto error;
2415         memcpy(str2, str, len);
2416         str2[len] = '\0';
2417         ret = inet_pton(AF_INET, str2, &tmp);
2418         if (ret != 1) {
2419                 /* Attempt integer parsing. */
2420                 push_args(ctx, arg);
2421                 return parse_int(ctx, token, str, len, buf, size);
2422         }
2423         if (!ctx->object)
2424                 return len;
2425         buf = (uint8_t *)ctx->object + arg->offset;
2426         memcpy(buf, &tmp, size);
2427         if (ctx->objmask)
2428                 memset((uint8_t *)ctx->objmask + arg->offset, 0xff, size);
2429         return len;
2430 error:
2431         push_args(ctx, arg);
2432         return -1;
2433 }
2434
2435 /**
2436  * Parse an IPv6 address.
2437  *
2438  * Last argument (ctx->args) is retrieved to determine storage size and
2439  * location.
2440  */
2441 static int
2442 parse_ipv6_addr(struct context *ctx, const struct token *token,
2443                 const char *str, unsigned int len,
2444                 void *buf, unsigned int size)
2445 {
2446         const struct arg *arg = pop_args(ctx);
2447         char str2[len + 1];
2448         struct in6_addr tmp;
2449         int ret;
2450
2451         (void)token;
2452         /* Argument is expected. */
2453         if (!arg)
2454                 return -1;
2455         size = arg->size;
2456         /* Bit-mask fill is not supported. */
2457         if (arg->mask || size != sizeof(tmp))
2458                 goto error;
2459         /* Only network endian is supported. */
2460         if (!arg->hton)
2461                 goto error;
2462         memcpy(str2, str, len);
2463         str2[len] = '\0';
2464         ret = inet_pton(AF_INET6, str2, &tmp);
2465         if (ret != 1)
2466                 goto error;
2467         if (!ctx->object)
2468                 return len;
2469         buf = (uint8_t *)ctx->object + arg->offset;
2470         memcpy(buf, &tmp, size);
2471         if (ctx->objmask)
2472                 memset((uint8_t *)ctx->objmask + arg->offset, 0xff, size);
2473         return len;
2474 error:
2475         push_args(ctx, arg);
2476         return -1;
2477 }
2478
2479 /** Boolean values (even indices stand for false). */
2480 static const char *const boolean_name[] = {
2481         "0", "1",
2482         "false", "true",
2483         "no", "yes",
2484         "N", "Y",
2485         NULL,
2486 };
2487
2488 /**
2489  * Parse a boolean value.
2490  *
2491  * Last argument (ctx->args) is retrieved to determine storage size and
2492  * location.
2493  */
2494 static int
2495 parse_boolean(struct context *ctx, const struct token *token,
2496               const char *str, unsigned int len,
2497               void *buf, unsigned int size)
2498 {
2499         const struct arg *arg = pop_args(ctx);
2500         unsigned int i;
2501         int ret;
2502
2503         /* Argument is expected. */
2504         if (!arg)
2505                 return -1;
2506         for (i = 0; boolean_name[i]; ++i)
2507                 if (!strcmp_partial(boolean_name[i], str, len))
2508                         break;
2509         /* Process token as integer. */
2510         if (boolean_name[i])
2511                 str = i & 1 ? "1" : "0";
2512         push_args(ctx, arg);
2513         ret = parse_int(ctx, token, str, strlen(str), buf, size);
2514         return ret > 0 ? (int)len : ret;
2515 }
2516
2517 /** Parse port and update context. */
2518 static int
2519 parse_port(struct context *ctx, const struct token *token,
2520            const char *str, unsigned int len,
2521            void *buf, unsigned int size)
2522 {
2523         struct buffer *out = &(struct buffer){ .port = 0 };
2524         int ret;
2525
2526         if (buf)
2527                 out = buf;
2528         else {
2529                 ctx->objdata = 0;
2530                 ctx->object = out;
2531                 ctx->objmask = NULL;
2532                 size = sizeof(*out);
2533         }
2534         ret = parse_int(ctx, token, str, len, out, size);
2535         if (ret >= 0)
2536                 ctx->port = out->port;
2537         if (!buf)
2538                 ctx->object = NULL;
2539         return ret;
2540 }
2541
2542 /** No completion. */
2543 static int
2544 comp_none(struct context *ctx, const struct token *token,
2545           unsigned int ent, char *buf, unsigned int size)
2546 {
2547         (void)ctx;
2548         (void)token;
2549         (void)ent;
2550         (void)buf;
2551         (void)size;
2552         return 0;
2553 }
2554
2555 /** Complete boolean values. */
2556 static int
2557 comp_boolean(struct context *ctx, const struct token *token,
2558              unsigned int ent, char *buf, unsigned int size)
2559 {
2560         unsigned int i;
2561
2562         (void)ctx;
2563         (void)token;
2564         for (i = 0; boolean_name[i]; ++i)
2565                 if (buf && i == ent)
2566                         return snprintf(buf, size, "%s", boolean_name[i]);
2567         if (buf)
2568                 return -1;
2569         return i;
2570 }
2571
2572 /** Complete action names. */
2573 static int
2574 comp_action(struct context *ctx, const struct token *token,
2575             unsigned int ent, char *buf, unsigned int size)
2576 {
2577         unsigned int i;
2578
2579         (void)ctx;
2580         (void)token;
2581         for (i = 0; next_action[i]; ++i)
2582                 if (buf && i == ent)
2583                         return snprintf(buf, size, "%s",
2584                                         token_list[next_action[i]].name);
2585         if (buf)
2586                 return -1;
2587         return i;
2588 }
2589
2590 /** Complete available ports. */
2591 static int
2592 comp_port(struct context *ctx, const struct token *token,
2593           unsigned int ent, char *buf, unsigned int size)
2594 {
2595         unsigned int i = 0;
2596         portid_t p;
2597
2598         (void)ctx;
2599         (void)token;
2600         RTE_ETH_FOREACH_DEV(p) {
2601                 if (buf && i == ent)
2602                         return snprintf(buf, size, "%u", p);
2603                 ++i;
2604         }
2605         if (buf)
2606                 return -1;
2607         return i;
2608 }
2609
2610 /** Complete available rule IDs. */
2611 static int
2612 comp_rule_id(struct context *ctx, const struct token *token,
2613              unsigned int ent, char *buf, unsigned int size)
2614 {
2615         unsigned int i = 0;
2616         struct rte_port *port;
2617         struct port_flow *pf;
2618
2619         (void)token;
2620         if (port_id_is_invalid(ctx->port, DISABLED_WARN) ||
2621             ctx->port == (portid_t)RTE_PORT_ALL)
2622                 return -1;
2623         port = &ports[ctx->port];
2624         for (pf = port->flow_list; pf != NULL; pf = pf->next) {
2625                 if (buf && i == ent)
2626                         return snprintf(buf, size, "%u", pf->id);
2627                 ++i;
2628         }
2629         if (buf)
2630                 return -1;
2631         return i;
2632 }
2633
2634 /** Complete queue field for RSS action. */
2635 static int
2636 comp_vc_action_rss_queue(struct context *ctx, const struct token *token,
2637                          unsigned int ent, char *buf, unsigned int size)
2638 {
2639         static const char *const str[] = { "", "end", NULL };
2640         unsigned int i;
2641
2642         (void)ctx;
2643         (void)token;
2644         for (i = 0; str[i] != NULL; ++i)
2645                 if (buf && i == ent)
2646                         return snprintf(buf, size, "%s", str[i]);
2647         if (buf)
2648                 return -1;
2649         return i;
2650 }
2651
2652 /** Internal context. */
2653 static struct context cmd_flow_context;
2654
2655 /** Global parser instance (cmdline API). */
2656 cmdline_parse_inst_t cmd_flow;
2657
2658 /** Initialize context. */
2659 static void
2660 cmd_flow_context_init(struct context *ctx)
2661 {
2662         /* A full memset() is not necessary. */
2663         ctx->curr = ZERO;
2664         ctx->prev = ZERO;
2665         ctx->next_num = 0;
2666         ctx->args_num = 0;
2667         ctx->eol = 0;
2668         ctx->last = 0;
2669         ctx->port = 0;
2670         ctx->objdata = 0;
2671         ctx->object = NULL;
2672         ctx->objmask = NULL;
2673 }
2674
2675 /** Parse a token (cmdline API). */
2676 static int
2677 cmd_flow_parse(cmdline_parse_token_hdr_t *hdr, const char *src, void *result,
2678                unsigned int size)
2679 {
2680         struct context *ctx = &cmd_flow_context;
2681         const struct token *token;
2682         const enum index *list;
2683         int len;
2684         int i;
2685
2686         (void)hdr;
2687         token = &token_list[ctx->curr];
2688         /* Check argument length. */
2689         ctx->eol = 0;
2690         ctx->last = 1;
2691         for (len = 0; src[len]; ++len)
2692                 if (src[len] == '#' || isspace(src[len]))
2693                         break;
2694         if (!len)
2695                 return -1;
2696         /* Last argument and EOL detection. */
2697         for (i = len; src[i]; ++i)
2698                 if (src[i] == '#' || src[i] == '\r' || src[i] == '\n')
2699                         break;
2700                 else if (!isspace(src[i])) {
2701                         ctx->last = 0;
2702                         break;
2703                 }
2704         for (; src[i]; ++i)
2705                 if (src[i] == '\r' || src[i] == '\n') {
2706                         ctx->eol = 1;
2707                         break;
2708                 }
2709         /* Initialize context if necessary. */
2710         if (!ctx->next_num) {
2711                 if (!token->next)
2712                         return 0;
2713                 ctx->next[ctx->next_num++] = token->next[0];
2714         }
2715         /* Process argument through candidates. */
2716         ctx->prev = ctx->curr;
2717         list = ctx->next[ctx->next_num - 1];
2718         for (i = 0; list[i]; ++i) {
2719                 const struct token *next = &token_list[list[i]];
2720                 int tmp;
2721
2722                 ctx->curr = list[i];
2723                 if (next->call)
2724                         tmp = next->call(ctx, next, src, len, result, size);
2725                 else
2726                         tmp = parse_default(ctx, next, src, len, result, size);
2727                 if (tmp == -1 || tmp != len)
2728                         continue;
2729                 token = next;
2730                 break;
2731         }
2732         if (!list[i])
2733                 return -1;
2734         --ctx->next_num;
2735         /* Push subsequent tokens if any. */
2736         if (token->next)
2737                 for (i = 0; token->next[i]; ++i) {
2738                         if (ctx->next_num == RTE_DIM(ctx->next))
2739                                 return -1;
2740                         ctx->next[ctx->next_num++] = token->next[i];
2741                 }
2742         /* Push arguments if any. */
2743         if (token->args)
2744                 for (i = 0; token->args[i]; ++i) {
2745                         if (ctx->args_num == RTE_DIM(ctx->args))
2746                                 return -1;
2747                         ctx->args[ctx->args_num++] = token->args[i];
2748                 }
2749         return len;
2750 }
2751
2752 /** Return number of completion entries (cmdline API). */
2753 static int
2754 cmd_flow_complete_get_nb(cmdline_parse_token_hdr_t *hdr)
2755 {
2756         struct context *ctx = &cmd_flow_context;
2757         const struct token *token = &token_list[ctx->curr];
2758         const enum index *list;
2759         int i;
2760
2761         (void)hdr;
2762         /* Count number of tokens in current list. */
2763         if (ctx->next_num)
2764                 list = ctx->next[ctx->next_num - 1];
2765         else
2766                 list = token->next[0];
2767         for (i = 0; list[i]; ++i)
2768                 ;
2769         if (!i)
2770                 return 0;
2771         /*
2772          * If there is a single token, use its completion callback, otherwise
2773          * return the number of entries.
2774          */
2775         token = &token_list[list[0]];
2776         if (i == 1 && token->comp) {
2777                 /* Save index for cmd_flow_get_help(). */
2778                 ctx->prev = list[0];
2779                 return token->comp(ctx, token, 0, NULL, 0);
2780         }
2781         return i;
2782 }
2783
2784 /** Return a completion entry (cmdline API). */
2785 static int
2786 cmd_flow_complete_get_elt(cmdline_parse_token_hdr_t *hdr, int index,
2787                           char *dst, unsigned int size)
2788 {
2789         struct context *ctx = &cmd_flow_context;
2790         const struct token *token = &token_list[ctx->curr];
2791         const enum index *list;
2792         int i;
2793
2794         (void)hdr;
2795         /* Count number of tokens in current list. */
2796         if (ctx->next_num)
2797                 list = ctx->next[ctx->next_num - 1];
2798         else
2799                 list = token->next[0];
2800         for (i = 0; list[i]; ++i)
2801                 ;
2802         if (!i)
2803                 return -1;
2804         /* If there is a single token, use its completion callback. */
2805         token = &token_list[list[0]];
2806         if (i == 1 && token->comp) {
2807                 /* Save index for cmd_flow_get_help(). */
2808                 ctx->prev = list[0];
2809                 return token->comp(ctx, token, index, dst, size) < 0 ? -1 : 0;
2810         }
2811         /* Otherwise make sure the index is valid and use defaults. */
2812         if (index >= i)
2813                 return -1;
2814         token = &token_list[list[index]];
2815         snprintf(dst, size, "%s", token->name);
2816         /* Save index for cmd_flow_get_help(). */
2817         ctx->prev = list[index];
2818         return 0;
2819 }
2820
2821 /** Populate help strings for current token (cmdline API). */
2822 static int
2823 cmd_flow_get_help(cmdline_parse_token_hdr_t *hdr, char *dst, unsigned int size)
2824 {
2825         struct context *ctx = &cmd_flow_context;
2826         const struct token *token = &token_list[ctx->prev];
2827
2828         (void)hdr;
2829         if (!size)
2830                 return -1;
2831         /* Set token type and update global help with details. */
2832         snprintf(dst, size, "%s", (token->type ? token->type : "TOKEN"));
2833         if (token->help)
2834                 cmd_flow.help_str = token->help;
2835         else
2836                 cmd_flow.help_str = token->name;
2837         return 0;
2838 }
2839
2840 /** Token definition template (cmdline API). */
2841 static struct cmdline_token_hdr cmd_flow_token_hdr = {
2842         .ops = &(struct cmdline_token_ops){
2843                 .parse = cmd_flow_parse,
2844                 .complete_get_nb = cmd_flow_complete_get_nb,
2845                 .complete_get_elt = cmd_flow_complete_get_elt,
2846                 .get_help = cmd_flow_get_help,
2847         },
2848         .offset = 0,
2849 };
2850
2851 /** Populate the next dynamic token. */
2852 static void
2853 cmd_flow_tok(cmdline_parse_token_hdr_t **hdr,
2854              cmdline_parse_token_hdr_t **hdr_inst)
2855 {
2856         struct context *ctx = &cmd_flow_context;
2857
2858         /* Always reinitialize context before requesting the first token. */
2859         if (!(hdr_inst - cmd_flow.tokens))
2860                 cmd_flow_context_init(ctx);
2861         /* Return NULL when no more tokens are expected. */
2862         if (!ctx->next_num && ctx->curr) {
2863                 *hdr = NULL;
2864                 return;
2865         }
2866         /* Determine if command should end here. */
2867         if (ctx->eol && ctx->last && ctx->next_num) {
2868                 const enum index *list = ctx->next[ctx->next_num - 1];
2869                 int i;
2870
2871                 for (i = 0; list[i]; ++i) {
2872                         if (list[i] != END)
2873                                 continue;
2874                         *hdr = NULL;
2875                         return;
2876                 }
2877         }
2878         *hdr = &cmd_flow_token_hdr;
2879 }
2880
2881 /** Dispatch parsed buffer to function calls. */
2882 static void
2883 cmd_flow_parsed(const struct buffer *in)
2884 {
2885         switch (in->command) {
2886         case VALIDATE:
2887                 port_flow_validate(in->port, &in->args.vc.attr,
2888                                    in->args.vc.pattern, in->args.vc.actions);
2889                 break;
2890         case CREATE:
2891                 port_flow_create(in->port, &in->args.vc.attr,
2892                                  in->args.vc.pattern, in->args.vc.actions);
2893                 break;
2894         case DESTROY:
2895                 port_flow_destroy(in->port, in->args.destroy.rule_n,
2896                                   in->args.destroy.rule);
2897                 break;
2898         case FLUSH:
2899                 port_flow_flush(in->port);
2900                 break;
2901         case QUERY:
2902                 port_flow_query(in->port, in->args.query.rule,
2903                                 in->args.query.action);
2904                 break;
2905         case LIST:
2906                 port_flow_list(in->port, in->args.list.group_n,
2907                                in->args.list.group);
2908                 break;
2909         case ISOLATE:
2910                 port_flow_isolate(in->port, in->args.isolate.set);
2911                 break;
2912         default:
2913                 break;
2914         }
2915 }
2916
2917 /** Token generator and output processing callback (cmdline API). */
2918 static void
2919 cmd_flow_cb(void *arg0, struct cmdline *cl, void *arg2)
2920 {
2921         if (cl == NULL)
2922                 cmd_flow_tok(arg0, arg2);
2923         else
2924                 cmd_flow_parsed(arg0);
2925 }
2926
2927 /** Global parser instance (cmdline API). */
2928 cmdline_parse_inst_t cmd_flow = {
2929         .f = cmd_flow_cb,
2930         .data = NULL, /**< Unused. */
2931         .help_str = NULL, /**< Updated by cmd_flow_get_help(). */
2932         .tokens = {
2933                 NULL,
2934         }, /**< Tokens are returned by cmd_flow_tok(). */
2935 };