xref: /dpdk/app/test-pmd/cmdline_flow.c (revision 2f82d143fb318042f47a50694baa4507b51b7381)
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright 2016 6WIND S.A.
3  * Copyright 2016 Mellanox Technologies, Ltd
4  */
5 
6 #include <stddef.h>
7 #include <stdint.h>
8 #include <stdio.h>
9 #include <inttypes.h>
10 #include <errno.h>
11 #include <ctype.h>
12 #include <string.h>
13 #include <arpa/inet.h>
14 #include <sys/socket.h>
15 
16 #include <rte_common.h>
17 #include <rte_eth_ctrl.h>
18 #include <rte_ethdev.h>
19 #include <rte_byteorder.h>
20 #include <cmdline_parse.h>
21 #include <cmdline_parse_etheraddr.h>
22 #include <rte_flow.h>
23 
24 #include "testpmd.h"
25 
26 /** Parser token indices. */
27 enum index {
28 	/* Special tokens. */
29 	ZERO = 0,
30 	END,
31 
32 	/* Common tokens. */
33 	INTEGER,
34 	UNSIGNED,
35 	PREFIX,
36 	BOOLEAN,
37 	STRING,
38 	MAC_ADDR,
39 	IPV4_ADDR,
40 	IPV6_ADDR,
41 	RULE_ID,
42 	PORT_ID,
43 	GROUP_ID,
44 	PRIORITY_LEVEL,
45 
46 	/* Top-level command. */
47 	FLOW,
48 
49 	/* Sub-level commands. */
50 	VALIDATE,
51 	CREATE,
52 	DESTROY,
53 	FLUSH,
54 	QUERY,
55 	LIST,
56 	ISOLATE,
57 
58 	/* Destroy arguments. */
59 	DESTROY_RULE,
60 
61 	/* Query arguments. */
62 	QUERY_ACTION,
63 
64 	/* List arguments. */
65 	LIST_GROUP,
66 
67 	/* Validate/create arguments. */
68 	GROUP,
69 	PRIORITY,
70 	INGRESS,
71 	EGRESS,
72 	TRANSFER,
73 
74 	/* Validate/create pattern. */
75 	PATTERN,
76 	ITEM_PARAM_IS,
77 	ITEM_PARAM_SPEC,
78 	ITEM_PARAM_LAST,
79 	ITEM_PARAM_MASK,
80 	ITEM_PARAM_PREFIX,
81 	ITEM_NEXT,
82 	ITEM_END,
83 	ITEM_VOID,
84 	ITEM_INVERT,
85 	ITEM_ANY,
86 	ITEM_ANY_NUM,
87 	ITEM_PF,
88 	ITEM_VF,
89 	ITEM_VF_ID,
90 	ITEM_PHY_PORT,
91 	ITEM_PHY_PORT_INDEX,
92 	ITEM_PORT_ID,
93 	ITEM_PORT_ID_ID,
94 	ITEM_RAW,
95 	ITEM_RAW_RELATIVE,
96 	ITEM_RAW_SEARCH,
97 	ITEM_RAW_OFFSET,
98 	ITEM_RAW_LIMIT,
99 	ITEM_RAW_PATTERN,
100 	ITEM_ETH,
101 	ITEM_ETH_DST,
102 	ITEM_ETH_SRC,
103 	ITEM_ETH_TYPE,
104 	ITEM_VLAN,
105 	ITEM_VLAN_TCI,
106 	ITEM_VLAN_PCP,
107 	ITEM_VLAN_DEI,
108 	ITEM_VLAN_VID,
109 	ITEM_VLAN_INNER_TYPE,
110 	ITEM_IPV4,
111 	ITEM_IPV4_TOS,
112 	ITEM_IPV4_TTL,
113 	ITEM_IPV4_PROTO,
114 	ITEM_IPV4_SRC,
115 	ITEM_IPV4_DST,
116 	ITEM_IPV6,
117 	ITEM_IPV6_TC,
118 	ITEM_IPV6_FLOW,
119 	ITEM_IPV6_PROTO,
120 	ITEM_IPV6_HOP,
121 	ITEM_IPV6_SRC,
122 	ITEM_IPV6_DST,
123 	ITEM_ICMP,
124 	ITEM_ICMP_TYPE,
125 	ITEM_ICMP_CODE,
126 	ITEM_UDP,
127 	ITEM_UDP_SRC,
128 	ITEM_UDP_DST,
129 	ITEM_TCP,
130 	ITEM_TCP_SRC,
131 	ITEM_TCP_DST,
132 	ITEM_TCP_FLAGS,
133 	ITEM_SCTP,
134 	ITEM_SCTP_SRC,
135 	ITEM_SCTP_DST,
136 	ITEM_SCTP_TAG,
137 	ITEM_SCTP_CKSUM,
138 	ITEM_VXLAN,
139 	ITEM_VXLAN_VNI,
140 	ITEM_E_TAG,
141 	ITEM_E_TAG_GRP_ECID_B,
142 	ITEM_NVGRE,
143 	ITEM_NVGRE_TNI,
144 	ITEM_MPLS,
145 	ITEM_MPLS_LABEL,
146 	ITEM_GRE,
147 	ITEM_GRE_PROTO,
148 	ITEM_FUZZY,
149 	ITEM_FUZZY_THRESH,
150 	ITEM_GTP,
151 	ITEM_GTP_TEID,
152 	ITEM_GTPC,
153 	ITEM_GTPU,
154 	ITEM_GENEVE,
155 	ITEM_GENEVE_VNI,
156 	ITEM_GENEVE_PROTO,
157 	ITEM_VXLAN_GPE,
158 	ITEM_VXLAN_GPE_VNI,
159 	ITEM_ARP_ETH_IPV4,
160 	ITEM_ARP_ETH_IPV4_SHA,
161 	ITEM_ARP_ETH_IPV4_SPA,
162 	ITEM_ARP_ETH_IPV4_THA,
163 	ITEM_ARP_ETH_IPV4_TPA,
164 	ITEM_IPV6_EXT,
165 	ITEM_IPV6_EXT_NEXT_HDR,
166 	ITEM_ICMP6,
167 	ITEM_ICMP6_TYPE,
168 	ITEM_ICMP6_CODE,
169 	ITEM_ICMP6_ND_NS,
170 	ITEM_ICMP6_ND_NS_TARGET_ADDR,
171 	ITEM_ICMP6_ND_NA,
172 	ITEM_ICMP6_ND_NA_TARGET_ADDR,
173 	ITEM_ICMP6_ND_OPT,
174 	ITEM_ICMP6_ND_OPT_TYPE,
175 	ITEM_ICMP6_ND_OPT_SLA_ETH,
176 	ITEM_ICMP6_ND_OPT_SLA_ETH_SLA,
177 	ITEM_ICMP6_ND_OPT_TLA_ETH,
178 	ITEM_ICMP6_ND_OPT_TLA_ETH_TLA,
179 
180 	/* Validate/create actions. */
181 	ACTIONS,
182 	ACTION_NEXT,
183 	ACTION_END,
184 	ACTION_VOID,
185 	ACTION_PASSTHRU,
186 	ACTION_JUMP,
187 	ACTION_JUMP_GROUP,
188 	ACTION_MARK,
189 	ACTION_MARK_ID,
190 	ACTION_FLAG,
191 	ACTION_QUEUE,
192 	ACTION_QUEUE_INDEX,
193 	ACTION_DROP,
194 	ACTION_COUNT,
195 	ACTION_RSS,
196 	ACTION_RSS_FUNC,
197 	ACTION_RSS_LEVEL,
198 	ACTION_RSS_FUNC_DEFAULT,
199 	ACTION_RSS_FUNC_TOEPLITZ,
200 	ACTION_RSS_FUNC_SIMPLE_XOR,
201 	ACTION_RSS_TYPES,
202 	ACTION_RSS_TYPE,
203 	ACTION_RSS_KEY,
204 	ACTION_RSS_KEY_LEN,
205 	ACTION_RSS_QUEUES,
206 	ACTION_RSS_QUEUE,
207 	ACTION_PF,
208 	ACTION_VF,
209 	ACTION_VF_ORIGINAL,
210 	ACTION_VF_ID,
211 	ACTION_PHY_PORT,
212 	ACTION_PHY_PORT_ORIGINAL,
213 	ACTION_PHY_PORT_INDEX,
214 	ACTION_PORT_ID,
215 	ACTION_PORT_ID_ORIGINAL,
216 	ACTION_PORT_ID_ID,
217 	ACTION_METER,
218 	ACTION_METER_ID,
219 	ACTION_OF_SET_MPLS_TTL,
220 	ACTION_OF_SET_MPLS_TTL_MPLS_TTL,
221 	ACTION_OF_DEC_MPLS_TTL,
222 	ACTION_OF_SET_NW_TTL,
223 	ACTION_OF_SET_NW_TTL_NW_TTL,
224 	ACTION_OF_DEC_NW_TTL,
225 	ACTION_OF_COPY_TTL_OUT,
226 	ACTION_OF_COPY_TTL_IN,
227 	ACTION_OF_POP_VLAN,
228 	ACTION_OF_PUSH_VLAN,
229 	ACTION_OF_PUSH_VLAN_ETHERTYPE,
230 	ACTION_OF_SET_VLAN_VID,
231 	ACTION_OF_SET_VLAN_VID_VLAN_VID,
232 	ACTION_OF_SET_VLAN_PCP,
233 	ACTION_OF_SET_VLAN_PCP_VLAN_PCP,
234 	ACTION_OF_POP_MPLS,
235 	ACTION_OF_POP_MPLS_ETHERTYPE,
236 	ACTION_OF_PUSH_MPLS,
237 	ACTION_OF_PUSH_MPLS_ETHERTYPE,
238 };
239 
240 /** Maximum size for pattern in struct rte_flow_item_raw. */
241 #define ITEM_RAW_PATTERN_SIZE 40
242 
243 /** Storage size for struct rte_flow_item_raw including pattern. */
244 #define ITEM_RAW_SIZE \
245 	(sizeof(struct rte_flow_item_raw) + ITEM_RAW_PATTERN_SIZE)
246 
247 /** Maximum number of queue indices in struct rte_flow_action_rss. */
248 #define ACTION_RSS_QUEUE_NUM 32
249 
250 /** Storage for struct rte_flow_action_rss including external data. */
251 struct action_rss_data {
252 	struct rte_flow_action_rss conf;
253 	uint8_t key[RSS_HASH_KEY_LENGTH];
254 	uint16_t queue[ACTION_RSS_QUEUE_NUM];
255 };
256 
257 /** Maximum number of subsequent tokens and arguments on the stack. */
258 #define CTX_STACK_SIZE 16
259 
260 /** Parser context. */
261 struct context {
262 	/** Stack of subsequent token lists to process. */
263 	const enum index *next[CTX_STACK_SIZE];
264 	/** Arguments for stacked tokens. */
265 	const void *args[CTX_STACK_SIZE];
266 	enum index curr; /**< Current token index. */
267 	enum index prev; /**< Index of the last token seen. */
268 	int next_num; /**< Number of entries in next[]. */
269 	int args_num; /**< Number of entries in args[]. */
270 	uint32_t eol:1; /**< EOL has been detected. */
271 	uint32_t last:1; /**< No more arguments. */
272 	portid_t port; /**< Current port ID (for completions). */
273 	uint32_t objdata; /**< Object-specific data. */
274 	void *object; /**< Address of current object for relative offsets. */
275 	void *objmask; /**< Object a full mask must be written to. */
276 };
277 
278 /** Token argument. */
279 struct arg {
280 	uint32_t hton:1; /**< Use network byte ordering. */
281 	uint32_t sign:1; /**< Value is signed. */
282 	uint32_t bounded:1; /**< Value is bounded. */
283 	uintmax_t min; /**< Minimum value if bounded. */
284 	uintmax_t max; /**< Maximum value if bounded. */
285 	uint32_t offset; /**< Relative offset from ctx->object. */
286 	uint32_t size; /**< Field size. */
287 	const uint8_t *mask; /**< Bit-mask to use instead of offset/size. */
288 };
289 
290 /** Parser token definition. */
291 struct token {
292 	/** Type displayed during completion (defaults to "TOKEN"). */
293 	const char *type;
294 	/** Help displayed during completion (defaults to token name). */
295 	const char *help;
296 	/** Private data used by parser functions. */
297 	const void *priv;
298 	/**
299 	 * Lists of subsequent tokens to push on the stack. Each call to the
300 	 * parser consumes the last entry of that stack.
301 	 */
302 	const enum index *const *next;
303 	/** Arguments stack for subsequent tokens that need them. */
304 	const struct arg *const *args;
305 	/**
306 	 * Token-processing callback, returns -1 in case of error, the
307 	 * length of the matched string otherwise. If NULL, attempts to
308 	 * match the token name.
309 	 *
310 	 * If buf is not NULL, the result should be stored in it according
311 	 * to context. An error is returned if not large enough.
312 	 */
313 	int (*call)(struct context *ctx, const struct token *token,
314 		    const char *str, unsigned int len,
315 		    void *buf, unsigned int size);
316 	/**
317 	 * Callback that provides possible values for this token, used for
318 	 * completion. Returns -1 in case of error, the number of possible
319 	 * values otherwise. If NULL, the token name is used.
320 	 *
321 	 * If buf is not NULL, entry index ent is written to buf and the
322 	 * full length of the entry is returned (same behavior as
323 	 * snprintf()).
324 	 */
325 	int (*comp)(struct context *ctx, const struct token *token,
326 		    unsigned int ent, char *buf, unsigned int size);
327 	/** Mandatory token name, no default value. */
328 	const char *name;
329 };
330 
331 /** Static initializer for the next field. */
332 #define NEXT(...) (const enum index *const []){ __VA_ARGS__, NULL, }
333 
334 /** Static initializer for a NEXT() entry. */
335 #define NEXT_ENTRY(...) (const enum index []){ __VA_ARGS__, ZERO, }
336 
337 /** Static initializer for the args field. */
338 #define ARGS(...) (const struct arg *const []){ __VA_ARGS__, NULL, }
339 
340 /** Static initializer for ARGS() to target a field. */
341 #define ARGS_ENTRY(s, f) \
342 	(&(const struct arg){ \
343 		.offset = offsetof(s, f), \
344 		.size = sizeof(((s *)0)->f), \
345 	})
346 
347 /** Static initializer for ARGS() to target a bit-field. */
348 #define ARGS_ENTRY_BF(s, f, b) \
349 	(&(const struct arg){ \
350 		.size = sizeof(s), \
351 		.mask = (const void *)&(const s){ .f = (1 << (b)) - 1 }, \
352 	})
353 
354 /** Static initializer for ARGS() to target an arbitrary bit-mask. */
355 #define ARGS_ENTRY_MASK(s, f, m) \
356 	(&(const struct arg){ \
357 		.offset = offsetof(s, f), \
358 		.size = sizeof(((s *)0)->f), \
359 		.mask = (const void *)(m), \
360 	})
361 
362 /** Same as ARGS_ENTRY_MASK() using network byte ordering for the value. */
363 #define ARGS_ENTRY_MASK_HTON(s, f, m) \
364 	(&(const struct arg){ \
365 		.hton = 1, \
366 		.offset = offsetof(s, f), \
367 		.size = sizeof(((s *)0)->f), \
368 		.mask = (const void *)(m), \
369 	})
370 
371 /** Static initializer for ARGS() to target a pointer. */
372 #define ARGS_ENTRY_PTR(s, f) \
373 	(&(const struct arg){ \
374 		.size = sizeof(*((s *)0)->f), \
375 	})
376 
377 /** Static initializer for ARGS() with arbitrary offset and size. */
378 #define ARGS_ENTRY_ARB(o, s) \
379 	(&(const struct arg){ \
380 		.offset = (o), \
381 		.size = (s), \
382 	})
383 
384 /** Same as ARGS_ENTRY_ARB() with bounded values. */
385 #define ARGS_ENTRY_ARB_BOUNDED(o, s, i, a) \
386 	(&(const struct arg){ \
387 		.bounded = 1, \
388 		.min = (i), \
389 		.max = (a), \
390 		.offset = (o), \
391 		.size = (s), \
392 	})
393 
394 /** Same as ARGS_ENTRY() using network byte ordering. */
395 #define ARGS_ENTRY_HTON(s, f) \
396 	(&(const struct arg){ \
397 		.hton = 1, \
398 		.offset = offsetof(s, f), \
399 		.size = sizeof(((s *)0)->f), \
400 	})
401 
402 /** Parser output buffer layout expected by cmd_flow_parsed(). */
403 struct buffer {
404 	enum index command; /**< Flow command. */
405 	portid_t port; /**< Affected port ID. */
406 	union {
407 		struct {
408 			struct rte_flow_attr attr;
409 			struct rte_flow_item *pattern;
410 			struct rte_flow_action *actions;
411 			uint32_t pattern_n;
412 			uint32_t actions_n;
413 			uint8_t *data;
414 		} vc; /**< Validate/create arguments. */
415 		struct {
416 			uint32_t *rule;
417 			uint32_t rule_n;
418 		} destroy; /**< Destroy arguments. */
419 		struct {
420 			uint32_t rule;
421 			enum rte_flow_action_type action;
422 		} query; /**< Query arguments. */
423 		struct {
424 			uint32_t *group;
425 			uint32_t group_n;
426 		} list; /**< List arguments. */
427 		struct {
428 			int set;
429 		} isolate; /**< Isolated mode arguments. */
430 	} args; /**< Command arguments. */
431 };
432 
433 /** Private data for pattern items. */
434 struct parse_item_priv {
435 	enum rte_flow_item_type type; /**< Item type. */
436 	uint32_t size; /**< Size of item specification structure. */
437 };
438 
439 #define PRIV_ITEM(t, s) \
440 	(&(const struct parse_item_priv){ \
441 		.type = RTE_FLOW_ITEM_TYPE_ ## t, \
442 		.size = s, \
443 	})
444 
445 /** Private data for actions. */
446 struct parse_action_priv {
447 	enum rte_flow_action_type type; /**< Action type. */
448 	uint32_t size; /**< Size of action configuration structure. */
449 };
450 
451 #define PRIV_ACTION(t, s) \
452 	(&(const struct parse_action_priv){ \
453 		.type = RTE_FLOW_ACTION_TYPE_ ## t, \
454 		.size = s, \
455 	})
456 
457 static const enum index next_vc_attr[] = {
458 	GROUP,
459 	PRIORITY,
460 	INGRESS,
461 	EGRESS,
462 	TRANSFER,
463 	PATTERN,
464 	ZERO,
465 };
466 
467 static const enum index next_destroy_attr[] = {
468 	DESTROY_RULE,
469 	END,
470 	ZERO,
471 };
472 
473 static const enum index next_list_attr[] = {
474 	LIST_GROUP,
475 	END,
476 	ZERO,
477 };
478 
479 static const enum index item_param[] = {
480 	ITEM_PARAM_IS,
481 	ITEM_PARAM_SPEC,
482 	ITEM_PARAM_LAST,
483 	ITEM_PARAM_MASK,
484 	ITEM_PARAM_PREFIX,
485 	ZERO,
486 };
487 
488 static const enum index next_item[] = {
489 	ITEM_END,
490 	ITEM_VOID,
491 	ITEM_INVERT,
492 	ITEM_ANY,
493 	ITEM_PF,
494 	ITEM_VF,
495 	ITEM_PHY_PORT,
496 	ITEM_PORT_ID,
497 	ITEM_RAW,
498 	ITEM_ETH,
499 	ITEM_VLAN,
500 	ITEM_IPV4,
501 	ITEM_IPV6,
502 	ITEM_ICMP,
503 	ITEM_UDP,
504 	ITEM_TCP,
505 	ITEM_SCTP,
506 	ITEM_VXLAN,
507 	ITEM_E_TAG,
508 	ITEM_NVGRE,
509 	ITEM_MPLS,
510 	ITEM_GRE,
511 	ITEM_FUZZY,
512 	ITEM_GTP,
513 	ITEM_GTPC,
514 	ITEM_GTPU,
515 	ITEM_GENEVE,
516 	ITEM_VXLAN_GPE,
517 	ITEM_ARP_ETH_IPV4,
518 	ITEM_IPV6_EXT,
519 	ITEM_ICMP6,
520 	ITEM_ICMP6_ND_NS,
521 	ITEM_ICMP6_ND_NA,
522 	ITEM_ICMP6_ND_OPT,
523 	ITEM_ICMP6_ND_OPT_SLA_ETH,
524 	ITEM_ICMP6_ND_OPT_TLA_ETH,
525 	ZERO,
526 };
527 
528 static const enum index item_fuzzy[] = {
529 	ITEM_FUZZY_THRESH,
530 	ITEM_NEXT,
531 	ZERO,
532 };
533 
534 static const enum index item_any[] = {
535 	ITEM_ANY_NUM,
536 	ITEM_NEXT,
537 	ZERO,
538 };
539 
540 static const enum index item_vf[] = {
541 	ITEM_VF_ID,
542 	ITEM_NEXT,
543 	ZERO,
544 };
545 
546 static const enum index item_phy_port[] = {
547 	ITEM_PHY_PORT_INDEX,
548 	ITEM_NEXT,
549 	ZERO,
550 };
551 
552 static const enum index item_port_id[] = {
553 	ITEM_PORT_ID_ID,
554 	ITEM_NEXT,
555 	ZERO,
556 };
557 
558 static const enum index item_raw[] = {
559 	ITEM_RAW_RELATIVE,
560 	ITEM_RAW_SEARCH,
561 	ITEM_RAW_OFFSET,
562 	ITEM_RAW_LIMIT,
563 	ITEM_RAW_PATTERN,
564 	ITEM_NEXT,
565 	ZERO,
566 };
567 
568 static const enum index item_eth[] = {
569 	ITEM_ETH_DST,
570 	ITEM_ETH_SRC,
571 	ITEM_ETH_TYPE,
572 	ITEM_NEXT,
573 	ZERO,
574 };
575 
576 static const enum index item_vlan[] = {
577 	ITEM_VLAN_TCI,
578 	ITEM_VLAN_PCP,
579 	ITEM_VLAN_DEI,
580 	ITEM_VLAN_VID,
581 	ITEM_VLAN_INNER_TYPE,
582 	ITEM_NEXT,
583 	ZERO,
584 };
585 
586 static const enum index item_ipv4[] = {
587 	ITEM_IPV4_TOS,
588 	ITEM_IPV4_TTL,
589 	ITEM_IPV4_PROTO,
590 	ITEM_IPV4_SRC,
591 	ITEM_IPV4_DST,
592 	ITEM_NEXT,
593 	ZERO,
594 };
595 
596 static const enum index item_ipv6[] = {
597 	ITEM_IPV6_TC,
598 	ITEM_IPV6_FLOW,
599 	ITEM_IPV6_PROTO,
600 	ITEM_IPV6_HOP,
601 	ITEM_IPV6_SRC,
602 	ITEM_IPV6_DST,
603 	ITEM_NEXT,
604 	ZERO,
605 };
606 
607 static const enum index item_icmp[] = {
608 	ITEM_ICMP_TYPE,
609 	ITEM_ICMP_CODE,
610 	ITEM_NEXT,
611 	ZERO,
612 };
613 
614 static const enum index item_udp[] = {
615 	ITEM_UDP_SRC,
616 	ITEM_UDP_DST,
617 	ITEM_NEXT,
618 	ZERO,
619 };
620 
621 static const enum index item_tcp[] = {
622 	ITEM_TCP_SRC,
623 	ITEM_TCP_DST,
624 	ITEM_TCP_FLAGS,
625 	ITEM_NEXT,
626 	ZERO,
627 };
628 
629 static const enum index item_sctp[] = {
630 	ITEM_SCTP_SRC,
631 	ITEM_SCTP_DST,
632 	ITEM_SCTP_TAG,
633 	ITEM_SCTP_CKSUM,
634 	ITEM_NEXT,
635 	ZERO,
636 };
637 
638 static const enum index item_vxlan[] = {
639 	ITEM_VXLAN_VNI,
640 	ITEM_NEXT,
641 	ZERO,
642 };
643 
644 static const enum index item_e_tag[] = {
645 	ITEM_E_TAG_GRP_ECID_B,
646 	ITEM_NEXT,
647 	ZERO,
648 };
649 
650 static const enum index item_nvgre[] = {
651 	ITEM_NVGRE_TNI,
652 	ITEM_NEXT,
653 	ZERO,
654 };
655 
656 static const enum index item_mpls[] = {
657 	ITEM_MPLS_LABEL,
658 	ITEM_NEXT,
659 	ZERO,
660 };
661 
662 static const enum index item_gre[] = {
663 	ITEM_GRE_PROTO,
664 	ITEM_NEXT,
665 	ZERO,
666 };
667 
668 static const enum index item_gtp[] = {
669 	ITEM_GTP_TEID,
670 	ITEM_NEXT,
671 	ZERO,
672 };
673 
674 static const enum index item_geneve[] = {
675 	ITEM_GENEVE_VNI,
676 	ITEM_GENEVE_PROTO,
677 	ITEM_NEXT,
678 	ZERO,
679 };
680 
681 static const enum index item_vxlan_gpe[] = {
682 	ITEM_VXLAN_GPE_VNI,
683 	ITEM_NEXT,
684 	ZERO,
685 };
686 
687 static const enum index item_arp_eth_ipv4[] = {
688 	ITEM_ARP_ETH_IPV4_SHA,
689 	ITEM_ARP_ETH_IPV4_SPA,
690 	ITEM_ARP_ETH_IPV4_THA,
691 	ITEM_ARP_ETH_IPV4_TPA,
692 	ITEM_NEXT,
693 	ZERO,
694 };
695 
696 static const enum index item_ipv6_ext[] = {
697 	ITEM_IPV6_EXT_NEXT_HDR,
698 	ITEM_NEXT,
699 	ZERO,
700 };
701 
702 static const enum index item_icmp6[] = {
703 	ITEM_ICMP6_TYPE,
704 	ITEM_ICMP6_CODE,
705 	ITEM_NEXT,
706 	ZERO,
707 };
708 
709 static const enum index item_icmp6_nd_ns[] = {
710 	ITEM_ICMP6_ND_NS_TARGET_ADDR,
711 	ITEM_NEXT,
712 	ZERO,
713 };
714 
715 static const enum index item_icmp6_nd_na[] = {
716 	ITEM_ICMP6_ND_NA_TARGET_ADDR,
717 	ITEM_NEXT,
718 	ZERO,
719 };
720 
721 static const enum index item_icmp6_nd_opt[] = {
722 	ITEM_ICMP6_ND_OPT_TYPE,
723 	ITEM_NEXT,
724 	ZERO,
725 };
726 
727 static const enum index item_icmp6_nd_opt_sla_eth[] = {
728 	ITEM_ICMP6_ND_OPT_SLA_ETH_SLA,
729 	ITEM_NEXT,
730 	ZERO,
731 };
732 
733 static const enum index item_icmp6_nd_opt_tla_eth[] = {
734 	ITEM_ICMP6_ND_OPT_TLA_ETH_TLA,
735 	ITEM_NEXT,
736 	ZERO,
737 };
738 
739 static const enum index next_action[] = {
740 	ACTION_END,
741 	ACTION_VOID,
742 	ACTION_PASSTHRU,
743 	ACTION_JUMP,
744 	ACTION_MARK,
745 	ACTION_FLAG,
746 	ACTION_QUEUE,
747 	ACTION_DROP,
748 	ACTION_COUNT,
749 	ACTION_RSS,
750 	ACTION_PF,
751 	ACTION_VF,
752 	ACTION_PHY_PORT,
753 	ACTION_PORT_ID,
754 	ACTION_METER,
755 	ACTION_OF_SET_MPLS_TTL,
756 	ACTION_OF_DEC_MPLS_TTL,
757 	ACTION_OF_SET_NW_TTL,
758 	ACTION_OF_DEC_NW_TTL,
759 	ACTION_OF_COPY_TTL_OUT,
760 	ACTION_OF_COPY_TTL_IN,
761 	ACTION_OF_POP_VLAN,
762 	ACTION_OF_PUSH_VLAN,
763 	ACTION_OF_SET_VLAN_VID,
764 	ACTION_OF_SET_VLAN_PCP,
765 	ACTION_OF_POP_MPLS,
766 	ACTION_OF_PUSH_MPLS,
767 	ZERO,
768 };
769 
770 static const enum index action_mark[] = {
771 	ACTION_MARK_ID,
772 	ACTION_NEXT,
773 	ZERO,
774 };
775 
776 static const enum index action_queue[] = {
777 	ACTION_QUEUE_INDEX,
778 	ACTION_NEXT,
779 	ZERO,
780 };
781 
782 static const enum index action_rss[] = {
783 	ACTION_RSS_FUNC,
784 	ACTION_RSS_LEVEL,
785 	ACTION_RSS_TYPES,
786 	ACTION_RSS_KEY,
787 	ACTION_RSS_KEY_LEN,
788 	ACTION_RSS_QUEUES,
789 	ACTION_NEXT,
790 	ZERO,
791 };
792 
793 static const enum index action_vf[] = {
794 	ACTION_VF_ORIGINAL,
795 	ACTION_VF_ID,
796 	ACTION_NEXT,
797 	ZERO,
798 };
799 
800 static const enum index action_phy_port[] = {
801 	ACTION_PHY_PORT_ORIGINAL,
802 	ACTION_PHY_PORT_INDEX,
803 	ACTION_NEXT,
804 	ZERO,
805 };
806 
807 static const enum index action_port_id[] = {
808 	ACTION_PORT_ID_ORIGINAL,
809 	ACTION_PORT_ID_ID,
810 	ACTION_NEXT,
811 	ZERO,
812 };
813 
814 static const enum index action_meter[] = {
815 	ACTION_METER_ID,
816 	ACTION_NEXT,
817 	ZERO,
818 };
819 
820 static const enum index action_of_set_mpls_ttl[] = {
821 	ACTION_OF_SET_MPLS_TTL_MPLS_TTL,
822 	ACTION_NEXT,
823 	ZERO,
824 };
825 
826 static const enum index action_of_set_nw_ttl[] = {
827 	ACTION_OF_SET_NW_TTL_NW_TTL,
828 	ACTION_NEXT,
829 	ZERO,
830 };
831 
832 static const enum index action_of_push_vlan[] = {
833 	ACTION_OF_PUSH_VLAN_ETHERTYPE,
834 	ACTION_NEXT,
835 	ZERO,
836 };
837 
838 static const enum index action_of_set_vlan_vid[] = {
839 	ACTION_OF_SET_VLAN_VID_VLAN_VID,
840 	ACTION_NEXT,
841 	ZERO,
842 };
843 
844 static const enum index action_of_set_vlan_pcp[] = {
845 	ACTION_OF_SET_VLAN_PCP_VLAN_PCP,
846 	ACTION_NEXT,
847 	ZERO,
848 };
849 
850 static const enum index action_of_pop_mpls[] = {
851 	ACTION_OF_POP_MPLS_ETHERTYPE,
852 	ACTION_NEXT,
853 	ZERO,
854 };
855 
856 static const enum index action_of_push_mpls[] = {
857 	ACTION_OF_PUSH_MPLS_ETHERTYPE,
858 	ACTION_NEXT,
859 	ZERO,
860 };
861 
862 static const enum index action_jump[] = {
863 	ACTION_JUMP_GROUP,
864 	ACTION_NEXT,
865 	ZERO,
866 };
867 
868 static int parse_init(struct context *, const struct token *,
869 		      const char *, unsigned int,
870 		      void *, unsigned int);
871 static int parse_vc(struct context *, const struct token *,
872 		    const char *, unsigned int,
873 		    void *, unsigned int);
874 static int parse_vc_spec(struct context *, const struct token *,
875 			 const char *, unsigned int, void *, unsigned int);
876 static int parse_vc_conf(struct context *, const struct token *,
877 			 const char *, unsigned int, void *, unsigned int);
878 static int parse_vc_action_rss(struct context *, const struct token *,
879 			       const char *, unsigned int, void *,
880 			       unsigned int);
881 static int parse_vc_action_rss_func(struct context *, const struct token *,
882 				    const char *, unsigned int, void *,
883 				    unsigned int);
884 static int parse_vc_action_rss_type(struct context *, const struct token *,
885 				    const char *, unsigned int, void *,
886 				    unsigned int);
887 static int parse_vc_action_rss_queue(struct context *, const struct token *,
888 				     const char *, unsigned int, void *,
889 				     unsigned int);
890 static int parse_destroy(struct context *, const struct token *,
891 			 const char *, unsigned int,
892 			 void *, unsigned int);
893 static int parse_flush(struct context *, const struct token *,
894 		       const char *, unsigned int,
895 		       void *, unsigned int);
896 static int parse_query(struct context *, const struct token *,
897 		       const char *, unsigned int,
898 		       void *, unsigned int);
899 static int parse_action(struct context *, const struct token *,
900 			const char *, unsigned int,
901 			void *, unsigned int);
902 static int parse_list(struct context *, const struct token *,
903 		      const char *, unsigned int,
904 		      void *, unsigned int);
905 static int parse_isolate(struct context *, const struct token *,
906 			 const char *, unsigned int,
907 			 void *, unsigned int);
908 static int parse_int(struct context *, const struct token *,
909 		     const char *, unsigned int,
910 		     void *, unsigned int);
911 static int parse_prefix(struct context *, const struct token *,
912 			const char *, unsigned int,
913 			void *, unsigned int);
914 static int parse_boolean(struct context *, const struct token *,
915 			 const char *, unsigned int,
916 			 void *, unsigned int);
917 static int parse_string(struct context *, const struct token *,
918 			const char *, unsigned int,
919 			void *, unsigned int);
920 static int parse_mac_addr(struct context *, const struct token *,
921 			  const char *, unsigned int,
922 			  void *, unsigned int);
923 static int parse_ipv4_addr(struct context *, const struct token *,
924 			   const char *, unsigned int,
925 			   void *, unsigned int);
926 static int parse_ipv6_addr(struct context *, const struct token *,
927 			   const char *, unsigned int,
928 			   void *, unsigned int);
929 static int parse_port(struct context *, const struct token *,
930 		      const char *, unsigned int,
931 		      void *, unsigned int);
932 static int comp_none(struct context *, const struct token *,
933 		     unsigned int, char *, unsigned int);
934 static int comp_boolean(struct context *, const struct token *,
935 			unsigned int, char *, unsigned int);
936 static int comp_action(struct context *, const struct token *,
937 		       unsigned int, char *, unsigned int);
938 static int comp_port(struct context *, const struct token *,
939 		     unsigned int, char *, unsigned int);
940 static int comp_rule_id(struct context *, const struct token *,
941 			unsigned int, char *, unsigned int);
942 static int comp_vc_action_rss_type(struct context *, const struct token *,
943 				   unsigned int, char *, unsigned int);
944 static int comp_vc_action_rss_queue(struct context *, const struct token *,
945 				    unsigned int, char *, unsigned int);
946 
947 /** Token definitions. */
948 static const struct token token_list[] = {
949 	/* Special tokens. */
950 	[ZERO] = {
951 		.name = "ZERO",
952 		.help = "null entry, abused as the entry point",
953 		.next = NEXT(NEXT_ENTRY(FLOW)),
954 	},
955 	[END] = {
956 		.name = "",
957 		.type = "RETURN",
958 		.help = "command may end here",
959 	},
960 	/* Common tokens. */
961 	[INTEGER] = {
962 		.name = "{int}",
963 		.type = "INTEGER",
964 		.help = "integer value",
965 		.call = parse_int,
966 		.comp = comp_none,
967 	},
968 	[UNSIGNED] = {
969 		.name = "{unsigned}",
970 		.type = "UNSIGNED",
971 		.help = "unsigned integer value",
972 		.call = parse_int,
973 		.comp = comp_none,
974 	},
975 	[PREFIX] = {
976 		.name = "{prefix}",
977 		.type = "PREFIX",
978 		.help = "prefix length for bit-mask",
979 		.call = parse_prefix,
980 		.comp = comp_none,
981 	},
982 	[BOOLEAN] = {
983 		.name = "{boolean}",
984 		.type = "BOOLEAN",
985 		.help = "any boolean value",
986 		.call = parse_boolean,
987 		.comp = comp_boolean,
988 	},
989 	[STRING] = {
990 		.name = "{string}",
991 		.type = "STRING",
992 		.help = "fixed string",
993 		.call = parse_string,
994 		.comp = comp_none,
995 	},
996 	[MAC_ADDR] = {
997 		.name = "{MAC address}",
998 		.type = "MAC-48",
999 		.help = "standard MAC address notation",
1000 		.call = parse_mac_addr,
1001 		.comp = comp_none,
1002 	},
1003 	[IPV4_ADDR] = {
1004 		.name = "{IPv4 address}",
1005 		.type = "IPV4 ADDRESS",
1006 		.help = "standard IPv4 address notation",
1007 		.call = parse_ipv4_addr,
1008 		.comp = comp_none,
1009 	},
1010 	[IPV6_ADDR] = {
1011 		.name = "{IPv6 address}",
1012 		.type = "IPV6 ADDRESS",
1013 		.help = "standard IPv6 address notation",
1014 		.call = parse_ipv6_addr,
1015 		.comp = comp_none,
1016 	},
1017 	[RULE_ID] = {
1018 		.name = "{rule id}",
1019 		.type = "RULE ID",
1020 		.help = "rule identifier",
1021 		.call = parse_int,
1022 		.comp = comp_rule_id,
1023 	},
1024 	[PORT_ID] = {
1025 		.name = "{port_id}",
1026 		.type = "PORT ID",
1027 		.help = "port identifier",
1028 		.call = parse_port,
1029 		.comp = comp_port,
1030 	},
1031 	[GROUP_ID] = {
1032 		.name = "{group_id}",
1033 		.type = "GROUP ID",
1034 		.help = "group identifier",
1035 		.call = parse_int,
1036 		.comp = comp_none,
1037 	},
1038 	[PRIORITY_LEVEL] = {
1039 		.name = "{level}",
1040 		.type = "PRIORITY",
1041 		.help = "priority level",
1042 		.call = parse_int,
1043 		.comp = comp_none,
1044 	},
1045 	/* Top-level command. */
1046 	[FLOW] = {
1047 		.name = "flow",
1048 		.type = "{command} {port_id} [{arg} [...]]",
1049 		.help = "manage ingress/egress flow rules",
1050 		.next = NEXT(NEXT_ENTRY
1051 			     (VALIDATE,
1052 			      CREATE,
1053 			      DESTROY,
1054 			      FLUSH,
1055 			      LIST,
1056 			      QUERY,
1057 			      ISOLATE)),
1058 		.call = parse_init,
1059 	},
1060 	/* Sub-level commands. */
1061 	[VALIDATE] = {
1062 		.name = "validate",
1063 		.help = "check whether a flow rule can be created",
1064 		.next = NEXT(next_vc_attr, NEXT_ENTRY(PORT_ID)),
1065 		.args = ARGS(ARGS_ENTRY(struct buffer, port)),
1066 		.call = parse_vc,
1067 	},
1068 	[CREATE] = {
1069 		.name = "create",
1070 		.help = "create a flow rule",
1071 		.next = NEXT(next_vc_attr, NEXT_ENTRY(PORT_ID)),
1072 		.args = ARGS(ARGS_ENTRY(struct buffer, port)),
1073 		.call = parse_vc,
1074 	},
1075 	[DESTROY] = {
1076 		.name = "destroy",
1077 		.help = "destroy specific flow rules",
1078 		.next = NEXT(NEXT_ENTRY(DESTROY_RULE), NEXT_ENTRY(PORT_ID)),
1079 		.args = ARGS(ARGS_ENTRY(struct buffer, port)),
1080 		.call = parse_destroy,
1081 	},
1082 	[FLUSH] = {
1083 		.name = "flush",
1084 		.help = "destroy all flow rules",
1085 		.next = NEXT(NEXT_ENTRY(PORT_ID)),
1086 		.args = ARGS(ARGS_ENTRY(struct buffer, port)),
1087 		.call = parse_flush,
1088 	},
1089 	[QUERY] = {
1090 		.name = "query",
1091 		.help = "query an existing flow rule",
1092 		.next = NEXT(NEXT_ENTRY(QUERY_ACTION),
1093 			     NEXT_ENTRY(RULE_ID),
1094 			     NEXT_ENTRY(PORT_ID)),
1095 		.args = ARGS(ARGS_ENTRY(struct buffer, args.query.action),
1096 			     ARGS_ENTRY(struct buffer, args.query.rule),
1097 			     ARGS_ENTRY(struct buffer, port)),
1098 		.call = parse_query,
1099 	},
1100 	[LIST] = {
1101 		.name = "list",
1102 		.help = "list existing flow rules",
1103 		.next = NEXT(next_list_attr, NEXT_ENTRY(PORT_ID)),
1104 		.args = ARGS(ARGS_ENTRY(struct buffer, port)),
1105 		.call = parse_list,
1106 	},
1107 	[ISOLATE] = {
1108 		.name = "isolate",
1109 		.help = "restrict ingress traffic to the defined flow rules",
1110 		.next = NEXT(NEXT_ENTRY(BOOLEAN),
1111 			     NEXT_ENTRY(PORT_ID)),
1112 		.args = ARGS(ARGS_ENTRY(struct buffer, args.isolate.set),
1113 			     ARGS_ENTRY(struct buffer, port)),
1114 		.call = parse_isolate,
1115 	},
1116 	/* Destroy arguments. */
1117 	[DESTROY_RULE] = {
1118 		.name = "rule",
1119 		.help = "specify a rule identifier",
1120 		.next = NEXT(next_destroy_attr, NEXT_ENTRY(RULE_ID)),
1121 		.args = ARGS(ARGS_ENTRY_PTR(struct buffer, args.destroy.rule)),
1122 		.call = parse_destroy,
1123 	},
1124 	/* Query arguments. */
1125 	[QUERY_ACTION] = {
1126 		.name = "{action}",
1127 		.type = "ACTION",
1128 		.help = "action to query, must be part of the rule",
1129 		.call = parse_action,
1130 		.comp = comp_action,
1131 	},
1132 	/* List arguments. */
1133 	[LIST_GROUP] = {
1134 		.name = "group",
1135 		.help = "specify a group",
1136 		.next = NEXT(next_list_attr, NEXT_ENTRY(GROUP_ID)),
1137 		.args = ARGS(ARGS_ENTRY_PTR(struct buffer, args.list.group)),
1138 		.call = parse_list,
1139 	},
1140 	/* Validate/create attributes. */
1141 	[GROUP] = {
1142 		.name = "group",
1143 		.help = "specify a group",
1144 		.next = NEXT(next_vc_attr, NEXT_ENTRY(GROUP_ID)),
1145 		.args = ARGS(ARGS_ENTRY(struct rte_flow_attr, group)),
1146 		.call = parse_vc,
1147 	},
1148 	[PRIORITY] = {
1149 		.name = "priority",
1150 		.help = "specify a priority level",
1151 		.next = NEXT(next_vc_attr, NEXT_ENTRY(PRIORITY_LEVEL)),
1152 		.args = ARGS(ARGS_ENTRY(struct rte_flow_attr, priority)),
1153 		.call = parse_vc,
1154 	},
1155 	[INGRESS] = {
1156 		.name = "ingress",
1157 		.help = "affect rule to ingress",
1158 		.next = NEXT(next_vc_attr),
1159 		.call = parse_vc,
1160 	},
1161 	[EGRESS] = {
1162 		.name = "egress",
1163 		.help = "affect rule to egress",
1164 		.next = NEXT(next_vc_attr),
1165 		.call = parse_vc,
1166 	},
1167 	[TRANSFER] = {
1168 		.name = "transfer",
1169 		.help = "apply rule directly to endpoints found in pattern",
1170 		.next = NEXT(next_vc_attr),
1171 		.call = parse_vc,
1172 	},
1173 	/* Validate/create pattern. */
1174 	[PATTERN] = {
1175 		.name = "pattern",
1176 		.help = "submit a list of pattern items",
1177 		.next = NEXT(next_item),
1178 		.call = parse_vc,
1179 	},
1180 	[ITEM_PARAM_IS] = {
1181 		.name = "is",
1182 		.help = "match value perfectly (with full bit-mask)",
1183 		.call = parse_vc_spec,
1184 	},
1185 	[ITEM_PARAM_SPEC] = {
1186 		.name = "spec",
1187 		.help = "match value according to configured bit-mask",
1188 		.call = parse_vc_spec,
1189 	},
1190 	[ITEM_PARAM_LAST] = {
1191 		.name = "last",
1192 		.help = "specify upper bound to establish a range",
1193 		.call = parse_vc_spec,
1194 	},
1195 	[ITEM_PARAM_MASK] = {
1196 		.name = "mask",
1197 		.help = "specify bit-mask with relevant bits set to one",
1198 		.call = parse_vc_spec,
1199 	},
1200 	[ITEM_PARAM_PREFIX] = {
1201 		.name = "prefix",
1202 		.help = "generate bit-mask from a prefix length",
1203 		.call = parse_vc_spec,
1204 	},
1205 	[ITEM_NEXT] = {
1206 		.name = "/",
1207 		.help = "specify next pattern item",
1208 		.next = NEXT(next_item),
1209 	},
1210 	[ITEM_END] = {
1211 		.name = "end",
1212 		.help = "end list of pattern items",
1213 		.priv = PRIV_ITEM(END, 0),
1214 		.next = NEXT(NEXT_ENTRY(ACTIONS)),
1215 		.call = parse_vc,
1216 	},
1217 	[ITEM_VOID] = {
1218 		.name = "void",
1219 		.help = "no-op pattern item",
1220 		.priv = PRIV_ITEM(VOID, 0),
1221 		.next = NEXT(NEXT_ENTRY(ITEM_NEXT)),
1222 		.call = parse_vc,
1223 	},
1224 	[ITEM_INVERT] = {
1225 		.name = "invert",
1226 		.help = "perform actions when pattern does not match",
1227 		.priv = PRIV_ITEM(INVERT, 0),
1228 		.next = NEXT(NEXT_ENTRY(ITEM_NEXT)),
1229 		.call = parse_vc,
1230 	},
1231 	[ITEM_ANY] = {
1232 		.name = "any",
1233 		.help = "match any protocol for the current layer",
1234 		.priv = PRIV_ITEM(ANY, sizeof(struct rte_flow_item_any)),
1235 		.next = NEXT(item_any),
1236 		.call = parse_vc,
1237 	},
1238 	[ITEM_ANY_NUM] = {
1239 		.name = "num",
1240 		.help = "number of layers covered",
1241 		.next = NEXT(item_any, NEXT_ENTRY(UNSIGNED), item_param),
1242 		.args = ARGS(ARGS_ENTRY(struct rte_flow_item_any, num)),
1243 	},
1244 	[ITEM_PF] = {
1245 		.name = "pf",
1246 		.help = "match traffic from/to the physical function",
1247 		.priv = PRIV_ITEM(PF, 0),
1248 		.next = NEXT(NEXT_ENTRY(ITEM_NEXT)),
1249 		.call = parse_vc,
1250 	},
1251 	[ITEM_VF] = {
1252 		.name = "vf",
1253 		.help = "match traffic from/to a virtual function ID",
1254 		.priv = PRIV_ITEM(VF, sizeof(struct rte_flow_item_vf)),
1255 		.next = NEXT(item_vf),
1256 		.call = parse_vc,
1257 	},
1258 	[ITEM_VF_ID] = {
1259 		.name = "id",
1260 		.help = "VF ID",
1261 		.next = NEXT(item_vf, NEXT_ENTRY(UNSIGNED), item_param),
1262 		.args = ARGS(ARGS_ENTRY(struct rte_flow_item_vf, id)),
1263 	},
1264 	[ITEM_PHY_PORT] = {
1265 		.name = "phy_port",
1266 		.help = "match traffic from/to a specific physical port",
1267 		.priv = PRIV_ITEM(PHY_PORT,
1268 				  sizeof(struct rte_flow_item_phy_port)),
1269 		.next = NEXT(item_phy_port),
1270 		.call = parse_vc,
1271 	},
1272 	[ITEM_PHY_PORT_INDEX] = {
1273 		.name = "index",
1274 		.help = "physical port index",
1275 		.next = NEXT(item_phy_port, NEXT_ENTRY(UNSIGNED), item_param),
1276 		.args = ARGS(ARGS_ENTRY(struct rte_flow_item_phy_port, index)),
1277 	},
1278 	[ITEM_PORT_ID] = {
1279 		.name = "port_id",
1280 		.help = "match traffic from/to a given DPDK port ID",
1281 		.priv = PRIV_ITEM(PORT_ID,
1282 				  sizeof(struct rte_flow_item_port_id)),
1283 		.next = NEXT(item_port_id),
1284 		.call = parse_vc,
1285 	},
1286 	[ITEM_PORT_ID_ID] = {
1287 		.name = "id",
1288 		.help = "DPDK port ID",
1289 		.next = NEXT(item_port_id, NEXT_ENTRY(UNSIGNED), item_param),
1290 		.args = ARGS(ARGS_ENTRY(struct rte_flow_item_port_id, id)),
1291 	},
1292 	[ITEM_RAW] = {
1293 		.name = "raw",
1294 		.help = "match an arbitrary byte string",
1295 		.priv = PRIV_ITEM(RAW, ITEM_RAW_SIZE),
1296 		.next = NEXT(item_raw),
1297 		.call = parse_vc,
1298 	},
1299 	[ITEM_RAW_RELATIVE] = {
1300 		.name = "relative",
1301 		.help = "look for pattern after the previous item",
1302 		.next = NEXT(item_raw, NEXT_ENTRY(BOOLEAN), item_param),
1303 		.args = ARGS(ARGS_ENTRY_BF(struct rte_flow_item_raw,
1304 					   relative, 1)),
1305 	},
1306 	[ITEM_RAW_SEARCH] = {
1307 		.name = "search",
1308 		.help = "search pattern from offset (see also limit)",
1309 		.next = NEXT(item_raw, NEXT_ENTRY(BOOLEAN), item_param),
1310 		.args = ARGS(ARGS_ENTRY_BF(struct rte_flow_item_raw,
1311 					   search, 1)),
1312 	},
1313 	[ITEM_RAW_OFFSET] = {
1314 		.name = "offset",
1315 		.help = "absolute or relative offset for pattern",
1316 		.next = NEXT(item_raw, NEXT_ENTRY(INTEGER), item_param),
1317 		.args = ARGS(ARGS_ENTRY(struct rte_flow_item_raw, offset)),
1318 	},
1319 	[ITEM_RAW_LIMIT] = {
1320 		.name = "limit",
1321 		.help = "search area limit for start of pattern",
1322 		.next = NEXT(item_raw, NEXT_ENTRY(UNSIGNED), item_param),
1323 		.args = ARGS(ARGS_ENTRY(struct rte_flow_item_raw, limit)),
1324 	},
1325 	[ITEM_RAW_PATTERN] = {
1326 		.name = "pattern",
1327 		.help = "byte string to look for",
1328 		.next = NEXT(item_raw,
1329 			     NEXT_ENTRY(STRING),
1330 			     NEXT_ENTRY(ITEM_PARAM_IS,
1331 					ITEM_PARAM_SPEC,
1332 					ITEM_PARAM_MASK)),
1333 		.args = ARGS(ARGS_ENTRY(struct rte_flow_item_raw, pattern),
1334 			     ARGS_ENTRY(struct rte_flow_item_raw, length),
1335 			     ARGS_ENTRY_ARB(sizeof(struct rte_flow_item_raw),
1336 					    ITEM_RAW_PATTERN_SIZE)),
1337 	},
1338 	[ITEM_ETH] = {
1339 		.name = "eth",
1340 		.help = "match Ethernet header",
1341 		.priv = PRIV_ITEM(ETH, sizeof(struct rte_flow_item_eth)),
1342 		.next = NEXT(item_eth),
1343 		.call = parse_vc,
1344 	},
1345 	[ITEM_ETH_DST] = {
1346 		.name = "dst",
1347 		.help = "destination MAC",
1348 		.next = NEXT(item_eth, NEXT_ENTRY(MAC_ADDR), item_param),
1349 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_eth, dst)),
1350 	},
1351 	[ITEM_ETH_SRC] = {
1352 		.name = "src",
1353 		.help = "source MAC",
1354 		.next = NEXT(item_eth, NEXT_ENTRY(MAC_ADDR), item_param),
1355 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_eth, src)),
1356 	},
1357 	[ITEM_ETH_TYPE] = {
1358 		.name = "type",
1359 		.help = "EtherType",
1360 		.next = NEXT(item_eth, NEXT_ENTRY(UNSIGNED), item_param),
1361 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_eth, type)),
1362 	},
1363 	[ITEM_VLAN] = {
1364 		.name = "vlan",
1365 		.help = "match 802.1Q/ad VLAN tag",
1366 		.priv = PRIV_ITEM(VLAN, sizeof(struct rte_flow_item_vlan)),
1367 		.next = NEXT(item_vlan),
1368 		.call = parse_vc,
1369 	},
1370 	[ITEM_VLAN_TCI] = {
1371 		.name = "tci",
1372 		.help = "tag control information",
1373 		.next = NEXT(item_vlan, NEXT_ENTRY(UNSIGNED), item_param),
1374 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_vlan, tci)),
1375 	},
1376 	[ITEM_VLAN_PCP] = {
1377 		.name = "pcp",
1378 		.help = "priority code point",
1379 		.next = NEXT(item_vlan, NEXT_ENTRY(UNSIGNED), item_param),
1380 		.args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_vlan,
1381 						  tci, "\xe0\x00")),
1382 	},
1383 	[ITEM_VLAN_DEI] = {
1384 		.name = "dei",
1385 		.help = "drop eligible indicator",
1386 		.next = NEXT(item_vlan, NEXT_ENTRY(UNSIGNED), item_param),
1387 		.args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_vlan,
1388 						  tci, "\x10\x00")),
1389 	},
1390 	[ITEM_VLAN_VID] = {
1391 		.name = "vid",
1392 		.help = "VLAN identifier",
1393 		.next = NEXT(item_vlan, NEXT_ENTRY(UNSIGNED), item_param),
1394 		.args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_vlan,
1395 						  tci, "\x0f\xff")),
1396 	},
1397 	[ITEM_VLAN_INNER_TYPE] = {
1398 		.name = "inner_type",
1399 		.help = "inner EtherType",
1400 		.next = NEXT(item_vlan, NEXT_ENTRY(UNSIGNED), item_param),
1401 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_vlan,
1402 					     inner_type)),
1403 	},
1404 	[ITEM_IPV4] = {
1405 		.name = "ipv4",
1406 		.help = "match IPv4 header",
1407 		.priv = PRIV_ITEM(IPV4, sizeof(struct rte_flow_item_ipv4)),
1408 		.next = NEXT(item_ipv4),
1409 		.call = parse_vc,
1410 	},
1411 	[ITEM_IPV4_TOS] = {
1412 		.name = "tos",
1413 		.help = "type of service",
1414 		.next = NEXT(item_ipv4, NEXT_ENTRY(UNSIGNED), item_param),
1415 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv4,
1416 					     hdr.type_of_service)),
1417 	},
1418 	[ITEM_IPV4_TTL] = {
1419 		.name = "ttl",
1420 		.help = "time to live",
1421 		.next = NEXT(item_ipv4, NEXT_ENTRY(UNSIGNED), item_param),
1422 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv4,
1423 					     hdr.time_to_live)),
1424 	},
1425 	[ITEM_IPV4_PROTO] = {
1426 		.name = "proto",
1427 		.help = "next protocol ID",
1428 		.next = NEXT(item_ipv4, NEXT_ENTRY(UNSIGNED), item_param),
1429 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv4,
1430 					     hdr.next_proto_id)),
1431 	},
1432 	[ITEM_IPV4_SRC] = {
1433 		.name = "src",
1434 		.help = "source address",
1435 		.next = NEXT(item_ipv4, NEXT_ENTRY(IPV4_ADDR), item_param),
1436 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv4,
1437 					     hdr.src_addr)),
1438 	},
1439 	[ITEM_IPV4_DST] = {
1440 		.name = "dst",
1441 		.help = "destination address",
1442 		.next = NEXT(item_ipv4, NEXT_ENTRY(IPV4_ADDR), item_param),
1443 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv4,
1444 					     hdr.dst_addr)),
1445 	},
1446 	[ITEM_IPV6] = {
1447 		.name = "ipv6",
1448 		.help = "match IPv6 header",
1449 		.priv = PRIV_ITEM(IPV6, sizeof(struct rte_flow_item_ipv6)),
1450 		.next = NEXT(item_ipv6),
1451 		.call = parse_vc,
1452 	},
1453 	[ITEM_IPV6_TC] = {
1454 		.name = "tc",
1455 		.help = "traffic class",
1456 		.next = NEXT(item_ipv6, NEXT_ENTRY(UNSIGNED), item_param),
1457 		.args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_ipv6,
1458 						  hdr.vtc_flow,
1459 						  "\x0f\xf0\x00\x00")),
1460 	},
1461 	[ITEM_IPV6_FLOW] = {
1462 		.name = "flow",
1463 		.help = "flow label",
1464 		.next = NEXT(item_ipv6, NEXT_ENTRY(UNSIGNED), item_param),
1465 		.args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_ipv6,
1466 						  hdr.vtc_flow,
1467 						  "\x00\x0f\xff\xff")),
1468 	},
1469 	[ITEM_IPV6_PROTO] = {
1470 		.name = "proto",
1471 		.help = "protocol (next header)",
1472 		.next = NEXT(item_ipv6, NEXT_ENTRY(UNSIGNED), item_param),
1473 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv6,
1474 					     hdr.proto)),
1475 	},
1476 	[ITEM_IPV6_HOP] = {
1477 		.name = "hop",
1478 		.help = "hop limit",
1479 		.next = NEXT(item_ipv6, NEXT_ENTRY(UNSIGNED), item_param),
1480 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv6,
1481 					     hdr.hop_limits)),
1482 	},
1483 	[ITEM_IPV6_SRC] = {
1484 		.name = "src",
1485 		.help = "source address",
1486 		.next = NEXT(item_ipv6, NEXT_ENTRY(IPV6_ADDR), item_param),
1487 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv6,
1488 					     hdr.src_addr)),
1489 	},
1490 	[ITEM_IPV6_DST] = {
1491 		.name = "dst",
1492 		.help = "destination address",
1493 		.next = NEXT(item_ipv6, NEXT_ENTRY(IPV6_ADDR), item_param),
1494 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv6,
1495 					     hdr.dst_addr)),
1496 	},
1497 	[ITEM_ICMP] = {
1498 		.name = "icmp",
1499 		.help = "match ICMP header",
1500 		.priv = PRIV_ITEM(ICMP, sizeof(struct rte_flow_item_icmp)),
1501 		.next = NEXT(item_icmp),
1502 		.call = parse_vc,
1503 	},
1504 	[ITEM_ICMP_TYPE] = {
1505 		.name = "type",
1506 		.help = "ICMP packet type",
1507 		.next = NEXT(item_icmp, NEXT_ENTRY(UNSIGNED), item_param),
1508 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_icmp,
1509 					     hdr.icmp_type)),
1510 	},
1511 	[ITEM_ICMP_CODE] = {
1512 		.name = "code",
1513 		.help = "ICMP packet code",
1514 		.next = NEXT(item_icmp, NEXT_ENTRY(UNSIGNED), item_param),
1515 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_icmp,
1516 					     hdr.icmp_code)),
1517 	},
1518 	[ITEM_UDP] = {
1519 		.name = "udp",
1520 		.help = "match UDP header",
1521 		.priv = PRIV_ITEM(UDP, sizeof(struct rte_flow_item_udp)),
1522 		.next = NEXT(item_udp),
1523 		.call = parse_vc,
1524 	},
1525 	[ITEM_UDP_SRC] = {
1526 		.name = "src",
1527 		.help = "UDP source port",
1528 		.next = NEXT(item_udp, NEXT_ENTRY(UNSIGNED), item_param),
1529 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_udp,
1530 					     hdr.src_port)),
1531 	},
1532 	[ITEM_UDP_DST] = {
1533 		.name = "dst",
1534 		.help = "UDP destination port",
1535 		.next = NEXT(item_udp, NEXT_ENTRY(UNSIGNED), item_param),
1536 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_udp,
1537 					     hdr.dst_port)),
1538 	},
1539 	[ITEM_TCP] = {
1540 		.name = "tcp",
1541 		.help = "match TCP header",
1542 		.priv = PRIV_ITEM(TCP, sizeof(struct rte_flow_item_tcp)),
1543 		.next = NEXT(item_tcp),
1544 		.call = parse_vc,
1545 	},
1546 	[ITEM_TCP_SRC] = {
1547 		.name = "src",
1548 		.help = "TCP source port",
1549 		.next = NEXT(item_tcp, NEXT_ENTRY(UNSIGNED), item_param),
1550 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_tcp,
1551 					     hdr.src_port)),
1552 	},
1553 	[ITEM_TCP_DST] = {
1554 		.name = "dst",
1555 		.help = "TCP destination port",
1556 		.next = NEXT(item_tcp, NEXT_ENTRY(UNSIGNED), item_param),
1557 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_tcp,
1558 					     hdr.dst_port)),
1559 	},
1560 	[ITEM_TCP_FLAGS] = {
1561 		.name = "flags",
1562 		.help = "TCP flags",
1563 		.next = NEXT(item_tcp, NEXT_ENTRY(UNSIGNED), item_param),
1564 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_tcp,
1565 					     hdr.tcp_flags)),
1566 	},
1567 	[ITEM_SCTP] = {
1568 		.name = "sctp",
1569 		.help = "match SCTP header",
1570 		.priv = PRIV_ITEM(SCTP, sizeof(struct rte_flow_item_sctp)),
1571 		.next = NEXT(item_sctp),
1572 		.call = parse_vc,
1573 	},
1574 	[ITEM_SCTP_SRC] = {
1575 		.name = "src",
1576 		.help = "SCTP source port",
1577 		.next = NEXT(item_sctp, NEXT_ENTRY(UNSIGNED), item_param),
1578 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_sctp,
1579 					     hdr.src_port)),
1580 	},
1581 	[ITEM_SCTP_DST] = {
1582 		.name = "dst",
1583 		.help = "SCTP destination port",
1584 		.next = NEXT(item_sctp, NEXT_ENTRY(UNSIGNED), item_param),
1585 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_sctp,
1586 					     hdr.dst_port)),
1587 	},
1588 	[ITEM_SCTP_TAG] = {
1589 		.name = "tag",
1590 		.help = "validation tag",
1591 		.next = NEXT(item_sctp, NEXT_ENTRY(UNSIGNED), item_param),
1592 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_sctp,
1593 					     hdr.tag)),
1594 	},
1595 	[ITEM_SCTP_CKSUM] = {
1596 		.name = "cksum",
1597 		.help = "checksum",
1598 		.next = NEXT(item_sctp, NEXT_ENTRY(UNSIGNED), item_param),
1599 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_sctp,
1600 					     hdr.cksum)),
1601 	},
1602 	[ITEM_VXLAN] = {
1603 		.name = "vxlan",
1604 		.help = "match VXLAN header",
1605 		.priv = PRIV_ITEM(VXLAN, sizeof(struct rte_flow_item_vxlan)),
1606 		.next = NEXT(item_vxlan),
1607 		.call = parse_vc,
1608 	},
1609 	[ITEM_VXLAN_VNI] = {
1610 		.name = "vni",
1611 		.help = "VXLAN identifier",
1612 		.next = NEXT(item_vxlan, NEXT_ENTRY(UNSIGNED), item_param),
1613 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_vxlan, vni)),
1614 	},
1615 	[ITEM_E_TAG] = {
1616 		.name = "e_tag",
1617 		.help = "match E-Tag header",
1618 		.priv = PRIV_ITEM(E_TAG, sizeof(struct rte_flow_item_e_tag)),
1619 		.next = NEXT(item_e_tag),
1620 		.call = parse_vc,
1621 	},
1622 	[ITEM_E_TAG_GRP_ECID_B] = {
1623 		.name = "grp_ecid_b",
1624 		.help = "GRP and E-CID base",
1625 		.next = NEXT(item_e_tag, NEXT_ENTRY(UNSIGNED), item_param),
1626 		.args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_e_tag,
1627 						  rsvd_grp_ecid_b,
1628 						  "\x3f\xff")),
1629 	},
1630 	[ITEM_NVGRE] = {
1631 		.name = "nvgre",
1632 		.help = "match NVGRE header",
1633 		.priv = PRIV_ITEM(NVGRE, sizeof(struct rte_flow_item_nvgre)),
1634 		.next = NEXT(item_nvgre),
1635 		.call = parse_vc,
1636 	},
1637 	[ITEM_NVGRE_TNI] = {
1638 		.name = "tni",
1639 		.help = "virtual subnet ID",
1640 		.next = NEXT(item_nvgre, NEXT_ENTRY(UNSIGNED), item_param),
1641 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_nvgre, tni)),
1642 	},
1643 	[ITEM_MPLS] = {
1644 		.name = "mpls",
1645 		.help = "match MPLS header",
1646 		.priv = PRIV_ITEM(MPLS, sizeof(struct rte_flow_item_mpls)),
1647 		.next = NEXT(item_mpls),
1648 		.call = parse_vc,
1649 	},
1650 	[ITEM_MPLS_LABEL] = {
1651 		.name = "label",
1652 		.help = "MPLS label",
1653 		.next = NEXT(item_mpls, NEXT_ENTRY(UNSIGNED), item_param),
1654 		.args = ARGS(ARGS_ENTRY_MASK_HTON(struct rte_flow_item_mpls,
1655 						  label_tc_s,
1656 						  "\xff\xff\xf0")),
1657 	},
1658 	[ITEM_GRE] = {
1659 		.name = "gre",
1660 		.help = "match GRE header",
1661 		.priv = PRIV_ITEM(GRE, sizeof(struct rte_flow_item_gre)),
1662 		.next = NEXT(item_gre),
1663 		.call = parse_vc,
1664 	},
1665 	[ITEM_GRE_PROTO] = {
1666 		.name = "protocol",
1667 		.help = "GRE protocol type",
1668 		.next = NEXT(item_gre, NEXT_ENTRY(UNSIGNED), item_param),
1669 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_gre,
1670 					     protocol)),
1671 	},
1672 	[ITEM_FUZZY] = {
1673 		.name = "fuzzy",
1674 		.help = "fuzzy pattern match, expect faster than default",
1675 		.priv = PRIV_ITEM(FUZZY,
1676 				sizeof(struct rte_flow_item_fuzzy)),
1677 		.next = NEXT(item_fuzzy),
1678 		.call = parse_vc,
1679 	},
1680 	[ITEM_FUZZY_THRESH] = {
1681 		.name = "thresh",
1682 		.help = "match accuracy threshold",
1683 		.next = NEXT(item_fuzzy, NEXT_ENTRY(UNSIGNED), item_param),
1684 		.args = ARGS(ARGS_ENTRY(struct rte_flow_item_fuzzy,
1685 					thresh)),
1686 	},
1687 	[ITEM_GTP] = {
1688 		.name = "gtp",
1689 		.help = "match GTP header",
1690 		.priv = PRIV_ITEM(GTP, sizeof(struct rte_flow_item_gtp)),
1691 		.next = NEXT(item_gtp),
1692 		.call = parse_vc,
1693 	},
1694 	[ITEM_GTP_TEID] = {
1695 		.name = "teid",
1696 		.help = "tunnel endpoint identifier",
1697 		.next = NEXT(item_gtp, NEXT_ENTRY(UNSIGNED), item_param),
1698 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_gtp, teid)),
1699 	},
1700 	[ITEM_GTPC] = {
1701 		.name = "gtpc",
1702 		.help = "match GTP header",
1703 		.priv = PRIV_ITEM(GTPC, sizeof(struct rte_flow_item_gtp)),
1704 		.next = NEXT(item_gtp),
1705 		.call = parse_vc,
1706 	},
1707 	[ITEM_GTPU] = {
1708 		.name = "gtpu",
1709 		.help = "match GTP header",
1710 		.priv = PRIV_ITEM(GTPU, sizeof(struct rte_flow_item_gtp)),
1711 		.next = NEXT(item_gtp),
1712 		.call = parse_vc,
1713 	},
1714 	[ITEM_GENEVE] = {
1715 		.name = "geneve",
1716 		.help = "match GENEVE header",
1717 		.priv = PRIV_ITEM(GENEVE, sizeof(struct rte_flow_item_geneve)),
1718 		.next = NEXT(item_geneve),
1719 		.call = parse_vc,
1720 	},
1721 	[ITEM_GENEVE_VNI] = {
1722 		.name = "vni",
1723 		.help = "virtual network identifier",
1724 		.next = NEXT(item_geneve, NEXT_ENTRY(UNSIGNED), item_param),
1725 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_geneve, vni)),
1726 	},
1727 	[ITEM_GENEVE_PROTO] = {
1728 		.name = "protocol",
1729 		.help = "GENEVE protocol type",
1730 		.next = NEXT(item_geneve, NEXT_ENTRY(UNSIGNED), item_param),
1731 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_geneve,
1732 					     protocol)),
1733 	},
1734 	[ITEM_VXLAN_GPE] = {
1735 		.name = "vxlan-gpe",
1736 		.help = "match VXLAN-GPE header",
1737 		.priv = PRIV_ITEM(VXLAN_GPE,
1738 				  sizeof(struct rte_flow_item_vxlan_gpe)),
1739 		.next = NEXT(item_vxlan_gpe),
1740 		.call = parse_vc,
1741 	},
1742 	[ITEM_VXLAN_GPE_VNI] = {
1743 		.name = "vni",
1744 		.help = "VXLAN-GPE identifier",
1745 		.next = NEXT(item_vxlan_gpe, NEXT_ENTRY(UNSIGNED), item_param),
1746 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_vxlan_gpe,
1747 					     vni)),
1748 	},
1749 	[ITEM_ARP_ETH_IPV4] = {
1750 		.name = "arp_eth_ipv4",
1751 		.help = "match ARP header for Ethernet/IPv4",
1752 		.priv = PRIV_ITEM(ARP_ETH_IPV4,
1753 				  sizeof(struct rte_flow_item_arp_eth_ipv4)),
1754 		.next = NEXT(item_arp_eth_ipv4),
1755 		.call = parse_vc,
1756 	},
1757 	[ITEM_ARP_ETH_IPV4_SHA] = {
1758 		.name = "sha",
1759 		.help = "sender hardware address",
1760 		.next = NEXT(item_arp_eth_ipv4, NEXT_ENTRY(MAC_ADDR),
1761 			     item_param),
1762 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_arp_eth_ipv4,
1763 					     sha)),
1764 	},
1765 	[ITEM_ARP_ETH_IPV4_SPA] = {
1766 		.name = "spa",
1767 		.help = "sender IPv4 address",
1768 		.next = NEXT(item_arp_eth_ipv4, NEXT_ENTRY(IPV4_ADDR),
1769 			     item_param),
1770 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_arp_eth_ipv4,
1771 					     spa)),
1772 	},
1773 	[ITEM_ARP_ETH_IPV4_THA] = {
1774 		.name = "tha",
1775 		.help = "target hardware address",
1776 		.next = NEXT(item_arp_eth_ipv4, NEXT_ENTRY(MAC_ADDR),
1777 			     item_param),
1778 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_arp_eth_ipv4,
1779 					     tha)),
1780 	},
1781 	[ITEM_ARP_ETH_IPV4_TPA] = {
1782 		.name = "tpa",
1783 		.help = "target IPv4 address",
1784 		.next = NEXT(item_arp_eth_ipv4, NEXT_ENTRY(IPV4_ADDR),
1785 			     item_param),
1786 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_arp_eth_ipv4,
1787 					     tpa)),
1788 	},
1789 	[ITEM_IPV6_EXT] = {
1790 		.name = "ipv6_ext",
1791 		.help = "match presence of any IPv6 extension header",
1792 		.priv = PRIV_ITEM(IPV6_EXT,
1793 				  sizeof(struct rte_flow_item_ipv6_ext)),
1794 		.next = NEXT(item_ipv6_ext),
1795 		.call = parse_vc,
1796 	},
1797 	[ITEM_IPV6_EXT_NEXT_HDR] = {
1798 		.name = "next_hdr",
1799 		.help = "next header",
1800 		.next = NEXT(item_ipv6_ext, NEXT_ENTRY(UNSIGNED), item_param),
1801 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_ipv6_ext,
1802 					     next_hdr)),
1803 	},
1804 	[ITEM_ICMP6] = {
1805 		.name = "icmp6",
1806 		.help = "match any ICMPv6 header",
1807 		.priv = PRIV_ITEM(ICMP6, sizeof(struct rte_flow_item_icmp6)),
1808 		.next = NEXT(item_icmp6),
1809 		.call = parse_vc,
1810 	},
1811 	[ITEM_ICMP6_TYPE] = {
1812 		.name = "type",
1813 		.help = "ICMPv6 type",
1814 		.next = NEXT(item_icmp6, NEXT_ENTRY(UNSIGNED), item_param),
1815 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_icmp6,
1816 					     type)),
1817 	},
1818 	[ITEM_ICMP6_CODE] = {
1819 		.name = "code",
1820 		.help = "ICMPv6 code",
1821 		.next = NEXT(item_icmp6, NEXT_ENTRY(UNSIGNED), item_param),
1822 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_icmp6,
1823 					     code)),
1824 	},
1825 	[ITEM_ICMP6_ND_NS] = {
1826 		.name = "icmp6_nd_ns",
1827 		.help = "match ICMPv6 neighbor discovery solicitation",
1828 		.priv = PRIV_ITEM(ICMP6_ND_NS,
1829 				  sizeof(struct rte_flow_item_icmp6_nd_ns)),
1830 		.next = NEXT(item_icmp6_nd_ns),
1831 		.call = parse_vc,
1832 	},
1833 	[ITEM_ICMP6_ND_NS_TARGET_ADDR] = {
1834 		.name = "target_addr",
1835 		.help = "target address",
1836 		.next = NEXT(item_icmp6_nd_ns, NEXT_ENTRY(IPV6_ADDR),
1837 			     item_param),
1838 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_icmp6_nd_ns,
1839 					     target_addr)),
1840 	},
1841 	[ITEM_ICMP6_ND_NA] = {
1842 		.name = "icmp6_nd_na",
1843 		.help = "match ICMPv6 neighbor discovery advertisement",
1844 		.priv = PRIV_ITEM(ICMP6_ND_NA,
1845 				  sizeof(struct rte_flow_item_icmp6_nd_na)),
1846 		.next = NEXT(item_icmp6_nd_na),
1847 		.call = parse_vc,
1848 	},
1849 	[ITEM_ICMP6_ND_NA_TARGET_ADDR] = {
1850 		.name = "target_addr",
1851 		.help = "target address",
1852 		.next = NEXT(item_icmp6_nd_na, NEXT_ENTRY(IPV6_ADDR),
1853 			     item_param),
1854 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_icmp6_nd_na,
1855 					     target_addr)),
1856 	},
1857 	[ITEM_ICMP6_ND_OPT] = {
1858 		.name = "icmp6_nd_opt",
1859 		.help = "match presence of any ICMPv6 neighbor discovery"
1860 			" option",
1861 		.priv = PRIV_ITEM(ICMP6_ND_OPT,
1862 				  sizeof(struct rte_flow_item_icmp6_nd_opt)),
1863 		.next = NEXT(item_icmp6_nd_opt),
1864 		.call = parse_vc,
1865 	},
1866 	[ITEM_ICMP6_ND_OPT_TYPE] = {
1867 		.name = "type",
1868 		.help = "ND option type",
1869 		.next = NEXT(item_icmp6_nd_opt, NEXT_ENTRY(UNSIGNED),
1870 			     item_param),
1871 		.args = ARGS(ARGS_ENTRY_HTON(struct rte_flow_item_icmp6_nd_opt,
1872 					     type)),
1873 	},
1874 	[ITEM_ICMP6_ND_OPT_SLA_ETH] = {
1875 		.name = "icmp6_nd_opt_sla_eth",
1876 		.help = "match ICMPv6 neighbor discovery source Ethernet"
1877 			" link-layer address option",
1878 		.priv = PRIV_ITEM
1879 			(ICMP6_ND_OPT_SLA_ETH,
1880 			 sizeof(struct rte_flow_item_icmp6_nd_opt_sla_eth)),
1881 		.next = NEXT(item_icmp6_nd_opt_sla_eth),
1882 		.call = parse_vc,
1883 	},
1884 	[ITEM_ICMP6_ND_OPT_SLA_ETH_SLA] = {
1885 		.name = "sla",
1886 		.help = "source Ethernet LLA",
1887 		.next = NEXT(item_icmp6_nd_opt_sla_eth, NEXT_ENTRY(MAC_ADDR),
1888 			     item_param),
1889 		.args = ARGS(ARGS_ENTRY_HTON
1890 			     (struct rte_flow_item_icmp6_nd_opt_sla_eth, sla)),
1891 	},
1892 	[ITEM_ICMP6_ND_OPT_TLA_ETH] = {
1893 		.name = "icmp6_nd_opt_tla_eth",
1894 		.help = "match ICMPv6 neighbor discovery target Ethernet"
1895 			" link-layer address option",
1896 		.priv = PRIV_ITEM
1897 			(ICMP6_ND_OPT_TLA_ETH,
1898 			 sizeof(struct rte_flow_item_icmp6_nd_opt_tla_eth)),
1899 		.next = NEXT(item_icmp6_nd_opt_tla_eth),
1900 		.call = parse_vc,
1901 	},
1902 	[ITEM_ICMP6_ND_OPT_TLA_ETH_TLA] = {
1903 		.name = "tla",
1904 		.help = "target Ethernet LLA",
1905 		.next = NEXT(item_icmp6_nd_opt_tla_eth, NEXT_ENTRY(MAC_ADDR),
1906 			     item_param),
1907 		.args = ARGS(ARGS_ENTRY_HTON
1908 			     (struct rte_flow_item_icmp6_nd_opt_tla_eth, tla)),
1909 	},
1910 
1911 	/* Validate/create actions. */
1912 	[ACTIONS] = {
1913 		.name = "actions",
1914 		.help = "submit a list of associated actions",
1915 		.next = NEXT(next_action),
1916 		.call = parse_vc,
1917 	},
1918 	[ACTION_NEXT] = {
1919 		.name = "/",
1920 		.help = "specify next action",
1921 		.next = NEXT(next_action),
1922 	},
1923 	[ACTION_END] = {
1924 		.name = "end",
1925 		.help = "end list of actions",
1926 		.priv = PRIV_ACTION(END, 0),
1927 		.call = parse_vc,
1928 	},
1929 	[ACTION_VOID] = {
1930 		.name = "void",
1931 		.help = "no-op action",
1932 		.priv = PRIV_ACTION(VOID, 0),
1933 		.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
1934 		.call = parse_vc,
1935 	},
1936 	[ACTION_PASSTHRU] = {
1937 		.name = "passthru",
1938 		.help = "let subsequent rule process matched packets",
1939 		.priv = PRIV_ACTION(PASSTHRU, 0),
1940 		.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
1941 		.call = parse_vc,
1942 	},
1943 	[ACTION_JUMP] = {
1944 		.name = "jump",
1945 		.help = "redirect traffic to a given group",
1946 		.priv = PRIV_ACTION(JUMP, sizeof(struct rte_flow_action_jump)),
1947 		.next = NEXT(action_jump),
1948 		.call = parse_vc,
1949 	},
1950 	[ACTION_JUMP_GROUP] = {
1951 		.name = "group",
1952 		.help = "group to redirect traffic to",
1953 		.next = NEXT(action_jump, NEXT_ENTRY(UNSIGNED)),
1954 		.args = ARGS(ARGS_ENTRY(struct rte_flow_action_jump, group)),
1955 		.call = parse_vc_conf,
1956 	},
1957 	[ACTION_MARK] = {
1958 		.name = "mark",
1959 		.help = "attach 32 bit value to packets",
1960 		.priv = PRIV_ACTION(MARK, sizeof(struct rte_flow_action_mark)),
1961 		.next = NEXT(action_mark),
1962 		.call = parse_vc,
1963 	},
1964 	[ACTION_MARK_ID] = {
1965 		.name = "id",
1966 		.help = "32 bit value to return with packets",
1967 		.next = NEXT(action_mark, NEXT_ENTRY(UNSIGNED)),
1968 		.args = ARGS(ARGS_ENTRY(struct rte_flow_action_mark, id)),
1969 		.call = parse_vc_conf,
1970 	},
1971 	[ACTION_FLAG] = {
1972 		.name = "flag",
1973 		.help = "flag packets",
1974 		.priv = PRIV_ACTION(FLAG, 0),
1975 		.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
1976 		.call = parse_vc,
1977 	},
1978 	[ACTION_QUEUE] = {
1979 		.name = "queue",
1980 		.help = "assign packets to a given queue index",
1981 		.priv = PRIV_ACTION(QUEUE,
1982 				    sizeof(struct rte_flow_action_queue)),
1983 		.next = NEXT(action_queue),
1984 		.call = parse_vc,
1985 	},
1986 	[ACTION_QUEUE_INDEX] = {
1987 		.name = "index",
1988 		.help = "queue index to use",
1989 		.next = NEXT(action_queue, NEXT_ENTRY(UNSIGNED)),
1990 		.args = ARGS(ARGS_ENTRY(struct rte_flow_action_queue, index)),
1991 		.call = parse_vc_conf,
1992 	},
1993 	[ACTION_DROP] = {
1994 		.name = "drop",
1995 		.help = "drop packets (note: passthru has priority)",
1996 		.priv = PRIV_ACTION(DROP, 0),
1997 		.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
1998 		.call = parse_vc,
1999 	},
2000 	[ACTION_COUNT] = {
2001 		.name = "count",
2002 		.help = "enable counters for this rule",
2003 		.priv = PRIV_ACTION(COUNT, 0),
2004 		.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
2005 		.call = parse_vc,
2006 	},
2007 	[ACTION_RSS] = {
2008 		.name = "rss",
2009 		.help = "spread packets among several queues",
2010 		.priv = PRIV_ACTION(RSS, sizeof(struct action_rss_data)),
2011 		.next = NEXT(action_rss),
2012 		.call = parse_vc_action_rss,
2013 	},
2014 	[ACTION_RSS_FUNC] = {
2015 		.name = "func",
2016 		.help = "RSS hash function to apply",
2017 		.next = NEXT(action_rss,
2018 			     NEXT_ENTRY(ACTION_RSS_FUNC_DEFAULT,
2019 					ACTION_RSS_FUNC_TOEPLITZ,
2020 					ACTION_RSS_FUNC_SIMPLE_XOR)),
2021 	},
2022 	[ACTION_RSS_FUNC_DEFAULT] = {
2023 		.name = "default",
2024 		.help = "default hash function",
2025 		.call = parse_vc_action_rss_func,
2026 	},
2027 	[ACTION_RSS_FUNC_TOEPLITZ] = {
2028 		.name = "toeplitz",
2029 		.help = "Toeplitz hash function",
2030 		.call = parse_vc_action_rss_func,
2031 	},
2032 	[ACTION_RSS_FUNC_SIMPLE_XOR] = {
2033 		.name = "simple_xor",
2034 		.help = "simple XOR hash function",
2035 		.call = parse_vc_action_rss_func,
2036 	},
2037 	[ACTION_RSS_LEVEL] = {
2038 		.name = "level",
2039 		.help = "encapsulation level for \"types\"",
2040 		.next = NEXT(action_rss, NEXT_ENTRY(UNSIGNED)),
2041 		.args = ARGS(ARGS_ENTRY_ARB
2042 			     (offsetof(struct action_rss_data, conf) +
2043 			      offsetof(struct rte_flow_action_rss, level),
2044 			      sizeof(((struct rte_flow_action_rss *)0)->
2045 				     level))),
2046 	},
2047 	[ACTION_RSS_TYPES] = {
2048 		.name = "types",
2049 		.help = "specific RSS hash types",
2050 		.next = NEXT(action_rss, NEXT_ENTRY(ACTION_RSS_TYPE)),
2051 	},
2052 	[ACTION_RSS_TYPE] = {
2053 		.name = "{type}",
2054 		.help = "RSS hash type",
2055 		.call = parse_vc_action_rss_type,
2056 		.comp = comp_vc_action_rss_type,
2057 	},
2058 	[ACTION_RSS_KEY] = {
2059 		.name = "key",
2060 		.help = "RSS hash key",
2061 		.next = NEXT(action_rss, NEXT_ENTRY(STRING)),
2062 		.args = ARGS(ARGS_ENTRY_ARB(0, 0),
2063 			     ARGS_ENTRY_ARB
2064 			     (offsetof(struct action_rss_data, conf) +
2065 			      offsetof(struct rte_flow_action_rss, key_len),
2066 			      sizeof(((struct rte_flow_action_rss *)0)->
2067 				     key_len)),
2068 			     ARGS_ENTRY(struct action_rss_data, key)),
2069 	},
2070 	[ACTION_RSS_KEY_LEN] = {
2071 		.name = "key_len",
2072 		.help = "RSS hash key length in bytes",
2073 		.next = NEXT(action_rss, NEXT_ENTRY(UNSIGNED)),
2074 		.args = ARGS(ARGS_ENTRY_ARB_BOUNDED
2075 			     (offsetof(struct action_rss_data, conf) +
2076 			      offsetof(struct rte_flow_action_rss, key_len),
2077 			      sizeof(((struct rte_flow_action_rss *)0)->
2078 				     key_len),
2079 			      0,
2080 			      RSS_HASH_KEY_LENGTH)),
2081 	},
2082 	[ACTION_RSS_QUEUES] = {
2083 		.name = "queues",
2084 		.help = "queue indices to use",
2085 		.next = NEXT(action_rss, NEXT_ENTRY(ACTION_RSS_QUEUE)),
2086 		.call = parse_vc_conf,
2087 	},
2088 	[ACTION_RSS_QUEUE] = {
2089 		.name = "{queue}",
2090 		.help = "queue index",
2091 		.call = parse_vc_action_rss_queue,
2092 		.comp = comp_vc_action_rss_queue,
2093 	},
2094 	[ACTION_PF] = {
2095 		.name = "pf",
2096 		.help = "direct traffic to physical function",
2097 		.priv = PRIV_ACTION(PF, 0),
2098 		.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
2099 		.call = parse_vc,
2100 	},
2101 	[ACTION_VF] = {
2102 		.name = "vf",
2103 		.help = "direct traffic to a virtual function ID",
2104 		.priv = PRIV_ACTION(VF, sizeof(struct rte_flow_action_vf)),
2105 		.next = NEXT(action_vf),
2106 		.call = parse_vc,
2107 	},
2108 	[ACTION_VF_ORIGINAL] = {
2109 		.name = "original",
2110 		.help = "use original VF ID if possible",
2111 		.next = NEXT(action_vf, NEXT_ENTRY(BOOLEAN)),
2112 		.args = ARGS(ARGS_ENTRY_BF(struct rte_flow_action_vf,
2113 					   original, 1)),
2114 		.call = parse_vc_conf,
2115 	},
2116 	[ACTION_VF_ID] = {
2117 		.name = "id",
2118 		.help = "VF ID",
2119 		.next = NEXT(action_vf, NEXT_ENTRY(UNSIGNED)),
2120 		.args = ARGS(ARGS_ENTRY(struct rte_flow_action_vf, id)),
2121 		.call = parse_vc_conf,
2122 	},
2123 	[ACTION_PHY_PORT] = {
2124 		.name = "phy_port",
2125 		.help = "direct packets to physical port index",
2126 		.priv = PRIV_ACTION(PHY_PORT,
2127 				    sizeof(struct rte_flow_action_phy_port)),
2128 		.next = NEXT(action_phy_port),
2129 		.call = parse_vc,
2130 	},
2131 	[ACTION_PHY_PORT_ORIGINAL] = {
2132 		.name = "original",
2133 		.help = "use original port index if possible",
2134 		.next = NEXT(action_phy_port, NEXT_ENTRY(BOOLEAN)),
2135 		.args = ARGS(ARGS_ENTRY_BF(struct rte_flow_action_phy_port,
2136 					   original, 1)),
2137 		.call = parse_vc_conf,
2138 	},
2139 	[ACTION_PHY_PORT_INDEX] = {
2140 		.name = "index",
2141 		.help = "physical port index",
2142 		.next = NEXT(action_phy_port, NEXT_ENTRY(UNSIGNED)),
2143 		.args = ARGS(ARGS_ENTRY(struct rte_flow_action_phy_port,
2144 					index)),
2145 		.call = parse_vc_conf,
2146 	},
2147 	[ACTION_PORT_ID] = {
2148 		.name = "port_id",
2149 		.help = "direct matching traffic to a given DPDK port ID",
2150 		.priv = PRIV_ACTION(PORT_ID,
2151 				    sizeof(struct rte_flow_action_port_id)),
2152 		.next = NEXT(action_port_id),
2153 		.call = parse_vc,
2154 	},
2155 	[ACTION_PORT_ID_ORIGINAL] = {
2156 		.name = "original",
2157 		.help = "use original DPDK port ID if possible",
2158 		.next = NEXT(action_port_id, NEXT_ENTRY(BOOLEAN)),
2159 		.args = ARGS(ARGS_ENTRY_BF(struct rte_flow_action_port_id,
2160 					   original, 1)),
2161 		.call = parse_vc_conf,
2162 	},
2163 	[ACTION_PORT_ID_ID] = {
2164 		.name = "id",
2165 		.help = "DPDK port ID",
2166 		.next = NEXT(action_port_id, NEXT_ENTRY(UNSIGNED)),
2167 		.args = ARGS(ARGS_ENTRY(struct rte_flow_action_port_id, id)),
2168 		.call = parse_vc_conf,
2169 	},
2170 	[ACTION_METER] = {
2171 		.name = "meter",
2172 		.help = "meter the directed packets at given id",
2173 		.priv = PRIV_ACTION(METER,
2174 				    sizeof(struct rte_flow_action_meter)),
2175 		.next = NEXT(action_meter),
2176 		.call = parse_vc,
2177 	},
2178 	[ACTION_METER_ID] = {
2179 		.name = "mtr_id",
2180 		.help = "meter id to use",
2181 		.next = NEXT(action_meter, NEXT_ENTRY(UNSIGNED)),
2182 		.args = ARGS(ARGS_ENTRY(struct rte_flow_action_meter, mtr_id)),
2183 		.call = parse_vc_conf,
2184 	},
2185 	[ACTION_OF_SET_MPLS_TTL] = {
2186 		.name = "of_set_mpls_ttl",
2187 		.help = "OpenFlow's OFPAT_SET_MPLS_TTL",
2188 		.priv = PRIV_ACTION
2189 			(OF_SET_MPLS_TTL,
2190 			 sizeof(struct rte_flow_action_of_set_mpls_ttl)),
2191 		.next = NEXT(action_of_set_mpls_ttl),
2192 		.call = parse_vc,
2193 	},
2194 	[ACTION_OF_SET_MPLS_TTL_MPLS_TTL] = {
2195 		.name = "mpls_ttl",
2196 		.help = "MPLS TTL",
2197 		.next = NEXT(action_of_set_mpls_ttl, NEXT_ENTRY(UNSIGNED)),
2198 		.args = ARGS(ARGS_ENTRY(struct rte_flow_action_of_set_mpls_ttl,
2199 					mpls_ttl)),
2200 		.call = parse_vc_conf,
2201 	},
2202 	[ACTION_OF_DEC_MPLS_TTL] = {
2203 		.name = "of_dec_mpls_ttl",
2204 		.help = "OpenFlow's OFPAT_DEC_MPLS_TTL",
2205 		.priv = PRIV_ACTION(OF_DEC_MPLS_TTL, 0),
2206 		.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
2207 		.call = parse_vc,
2208 	},
2209 	[ACTION_OF_SET_NW_TTL] = {
2210 		.name = "of_set_nw_ttl",
2211 		.help = "OpenFlow's OFPAT_SET_NW_TTL",
2212 		.priv = PRIV_ACTION
2213 			(OF_SET_NW_TTL,
2214 			 sizeof(struct rte_flow_action_of_set_nw_ttl)),
2215 		.next = NEXT(action_of_set_nw_ttl),
2216 		.call = parse_vc,
2217 	},
2218 	[ACTION_OF_SET_NW_TTL_NW_TTL] = {
2219 		.name = "nw_ttl",
2220 		.help = "IP TTL",
2221 		.next = NEXT(action_of_set_nw_ttl, NEXT_ENTRY(UNSIGNED)),
2222 		.args = ARGS(ARGS_ENTRY(struct rte_flow_action_of_set_nw_ttl,
2223 					nw_ttl)),
2224 		.call = parse_vc_conf,
2225 	},
2226 	[ACTION_OF_DEC_NW_TTL] = {
2227 		.name = "of_dec_nw_ttl",
2228 		.help = "OpenFlow's OFPAT_DEC_NW_TTL",
2229 		.priv = PRIV_ACTION(OF_DEC_NW_TTL, 0),
2230 		.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
2231 		.call = parse_vc,
2232 	},
2233 	[ACTION_OF_COPY_TTL_OUT] = {
2234 		.name = "of_copy_ttl_out",
2235 		.help = "OpenFlow's OFPAT_COPY_TTL_OUT",
2236 		.priv = PRIV_ACTION(OF_COPY_TTL_OUT, 0),
2237 		.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
2238 		.call = parse_vc,
2239 	},
2240 	[ACTION_OF_COPY_TTL_IN] = {
2241 		.name = "of_copy_ttl_in",
2242 		.help = "OpenFlow's OFPAT_COPY_TTL_IN",
2243 		.priv = PRIV_ACTION(OF_COPY_TTL_IN, 0),
2244 		.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
2245 		.call = parse_vc,
2246 	},
2247 	[ACTION_OF_POP_VLAN] = {
2248 		.name = "of_pop_vlan",
2249 		.help = "OpenFlow's OFPAT_POP_VLAN",
2250 		.priv = PRIV_ACTION(OF_POP_VLAN, 0),
2251 		.next = NEXT(NEXT_ENTRY(ACTION_NEXT)),
2252 		.call = parse_vc,
2253 	},
2254 	[ACTION_OF_PUSH_VLAN] = {
2255 		.name = "of_push_vlan",
2256 		.help = "OpenFlow's OFPAT_PUSH_VLAN",
2257 		.priv = PRIV_ACTION
2258 			(OF_PUSH_VLAN,
2259 			 sizeof(struct rte_flow_action_of_push_vlan)),
2260 		.next = NEXT(action_of_push_vlan),
2261 		.call = parse_vc,
2262 	},
2263 	[ACTION_OF_PUSH_VLAN_ETHERTYPE] = {
2264 		.name = "ethertype",
2265 		.help = "EtherType",
2266 		.next = NEXT(action_of_push_vlan, NEXT_ENTRY(UNSIGNED)),
2267 		.args = ARGS(ARGS_ENTRY_HTON
2268 			     (struct rte_flow_action_of_push_vlan,
2269 			      ethertype)),
2270 		.call = parse_vc_conf,
2271 	},
2272 	[ACTION_OF_SET_VLAN_VID] = {
2273 		.name = "of_set_vlan_vid",
2274 		.help = "OpenFlow's OFPAT_SET_VLAN_VID",
2275 		.priv = PRIV_ACTION
2276 			(OF_SET_VLAN_VID,
2277 			 sizeof(struct rte_flow_action_of_set_vlan_vid)),
2278 		.next = NEXT(action_of_set_vlan_vid),
2279 		.call = parse_vc,
2280 	},
2281 	[ACTION_OF_SET_VLAN_VID_VLAN_VID] = {
2282 		.name = "vlan_vid",
2283 		.help = "VLAN id",
2284 		.next = NEXT(action_of_set_vlan_vid, NEXT_ENTRY(UNSIGNED)),
2285 		.args = ARGS(ARGS_ENTRY_HTON
2286 			     (struct rte_flow_action_of_set_vlan_vid,
2287 			      vlan_vid)),
2288 		.call = parse_vc_conf,
2289 	},
2290 	[ACTION_OF_SET_VLAN_PCP] = {
2291 		.name = "of_set_vlan_pcp",
2292 		.help = "OpenFlow's OFPAT_SET_VLAN_PCP",
2293 		.priv = PRIV_ACTION
2294 			(OF_SET_VLAN_PCP,
2295 			 sizeof(struct rte_flow_action_of_set_vlan_pcp)),
2296 		.next = NEXT(action_of_set_vlan_pcp),
2297 		.call = parse_vc,
2298 	},
2299 	[ACTION_OF_SET_VLAN_PCP_VLAN_PCP] = {
2300 		.name = "vlan_pcp",
2301 		.help = "VLAN priority",
2302 		.next = NEXT(action_of_set_vlan_pcp, NEXT_ENTRY(UNSIGNED)),
2303 		.args = ARGS(ARGS_ENTRY_HTON
2304 			     (struct rte_flow_action_of_set_vlan_pcp,
2305 			      vlan_pcp)),
2306 		.call = parse_vc_conf,
2307 	},
2308 	[ACTION_OF_POP_MPLS] = {
2309 		.name = "of_pop_mpls",
2310 		.help = "OpenFlow's OFPAT_POP_MPLS",
2311 		.priv = PRIV_ACTION(OF_POP_MPLS,
2312 				    sizeof(struct rte_flow_action_of_pop_mpls)),
2313 		.next = NEXT(action_of_pop_mpls),
2314 		.call = parse_vc,
2315 	},
2316 	[ACTION_OF_POP_MPLS_ETHERTYPE] = {
2317 		.name = "ethertype",
2318 		.help = "EtherType",
2319 		.next = NEXT(action_of_pop_mpls, NEXT_ENTRY(UNSIGNED)),
2320 		.args = ARGS(ARGS_ENTRY_HTON
2321 			     (struct rte_flow_action_of_pop_mpls,
2322 			      ethertype)),
2323 		.call = parse_vc_conf,
2324 	},
2325 	[ACTION_OF_PUSH_MPLS] = {
2326 		.name = "of_push_mpls",
2327 		.help = "OpenFlow's OFPAT_PUSH_MPLS",
2328 		.priv = PRIV_ACTION
2329 			(OF_PUSH_MPLS,
2330 			 sizeof(struct rte_flow_action_of_push_mpls)),
2331 		.next = NEXT(action_of_push_mpls),
2332 		.call = parse_vc,
2333 	},
2334 	[ACTION_OF_PUSH_MPLS_ETHERTYPE] = {
2335 		.name = "ethertype",
2336 		.help = "EtherType",
2337 		.next = NEXT(action_of_push_mpls, NEXT_ENTRY(UNSIGNED)),
2338 		.args = ARGS(ARGS_ENTRY_HTON
2339 			     (struct rte_flow_action_of_push_mpls,
2340 			      ethertype)),
2341 		.call = parse_vc_conf,
2342 	},
2343 };
2344 
2345 /** Remove and return last entry from argument stack. */
2346 static const struct arg *
2347 pop_args(struct context *ctx)
2348 {
2349 	return ctx->args_num ? ctx->args[--ctx->args_num] : NULL;
2350 }
2351 
2352 /** Add entry on top of the argument stack. */
2353 static int
2354 push_args(struct context *ctx, const struct arg *arg)
2355 {
2356 	if (ctx->args_num == CTX_STACK_SIZE)
2357 		return -1;
2358 	ctx->args[ctx->args_num++] = arg;
2359 	return 0;
2360 }
2361 
2362 /** Spread value into buffer according to bit-mask. */
2363 static size_t
2364 arg_entry_bf_fill(void *dst, uintmax_t val, const struct arg *arg)
2365 {
2366 	uint32_t i = arg->size;
2367 	uint32_t end = 0;
2368 	int sub = 1;
2369 	int add = 0;
2370 	size_t len = 0;
2371 
2372 	if (!arg->mask)
2373 		return 0;
2374 #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
2375 	if (!arg->hton) {
2376 		i = 0;
2377 		end = arg->size;
2378 		sub = 0;
2379 		add = 1;
2380 	}
2381 #endif
2382 	while (i != end) {
2383 		unsigned int shift = 0;
2384 		uint8_t *buf = (uint8_t *)dst + arg->offset + (i -= sub);
2385 
2386 		for (shift = 0; arg->mask[i] >> shift; ++shift) {
2387 			if (!(arg->mask[i] & (1 << shift)))
2388 				continue;
2389 			++len;
2390 			if (!dst)
2391 				continue;
2392 			*buf &= ~(1 << shift);
2393 			*buf |= (val & 1) << shift;
2394 			val >>= 1;
2395 		}
2396 		i += add;
2397 	}
2398 	return len;
2399 }
2400 
2401 /** Compare a string with a partial one of a given length. */
2402 static int
2403 strcmp_partial(const char *full, const char *partial, size_t partial_len)
2404 {
2405 	int r = strncmp(full, partial, partial_len);
2406 
2407 	if (r)
2408 		return r;
2409 	if (strlen(full) <= partial_len)
2410 		return 0;
2411 	return full[partial_len];
2412 }
2413 
2414 /**
2415  * Parse a prefix length and generate a bit-mask.
2416  *
2417  * Last argument (ctx->args) is retrieved to determine mask size, storage
2418  * location and whether the result must use network byte ordering.
2419  */
2420 static int
2421 parse_prefix(struct context *ctx, const struct token *token,
2422 	     const char *str, unsigned int len,
2423 	     void *buf, unsigned int size)
2424 {
2425 	const struct arg *arg = pop_args(ctx);
2426 	static const uint8_t conv[] = "\x00\x80\xc0\xe0\xf0\xf8\xfc\xfe\xff";
2427 	char *end;
2428 	uintmax_t u;
2429 	unsigned int bytes;
2430 	unsigned int extra;
2431 
2432 	(void)token;
2433 	/* Argument is expected. */
2434 	if (!arg)
2435 		return -1;
2436 	errno = 0;
2437 	u = strtoumax(str, &end, 0);
2438 	if (errno || (size_t)(end - str) != len)
2439 		goto error;
2440 	if (arg->mask) {
2441 		uintmax_t v = 0;
2442 
2443 		extra = arg_entry_bf_fill(NULL, 0, arg);
2444 		if (u > extra)
2445 			goto error;
2446 		if (!ctx->object)
2447 			return len;
2448 		extra -= u;
2449 		while (u--)
2450 			(v <<= 1, v |= 1);
2451 		v <<= extra;
2452 		if (!arg_entry_bf_fill(ctx->object, v, arg) ||
2453 		    !arg_entry_bf_fill(ctx->objmask, -1, arg))
2454 			goto error;
2455 		return len;
2456 	}
2457 	bytes = u / 8;
2458 	extra = u % 8;
2459 	size = arg->size;
2460 	if (bytes > size || bytes + !!extra > size)
2461 		goto error;
2462 	if (!ctx->object)
2463 		return len;
2464 	buf = (uint8_t *)ctx->object + arg->offset;
2465 #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
2466 	if (!arg->hton) {
2467 		memset((uint8_t *)buf + size - bytes, 0xff, bytes);
2468 		memset(buf, 0x00, size - bytes);
2469 		if (extra)
2470 			((uint8_t *)buf)[size - bytes - 1] = conv[extra];
2471 	} else
2472 #endif
2473 	{
2474 		memset(buf, 0xff, bytes);
2475 		memset((uint8_t *)buf + bytes, 0x00, size - bytes);
2476 		if (extra)
2477 			((uint8_t *)buf)[bytes] = conv[extra];
2478 	}
2479 	if (ctx->objmask)
2480 		memset((uint8_t *)ctx->objmask + arg->offset, 0xff, size);
2481 	return len;
2482 error:
2483 	push_args(ctx, arg);
2484 	return -1;
2485 }
2486 
2487 /** Default parsing function for token name matching. */
2488 static int
2489 parse_default(struct context *ctx, const struct token *token,
2490 	      const char *str, unsigned int len,
2491 	      void *buf, unsigned int size)
2492 {
2493 	(void)ctx;
2494 	(void)buf;
2495 	(void)size;
2496 	if (strcmp_partial(token->name, str, len))
2497 		return -1;
2498 	return len;
2499 }
2500 
2501 /** Parse flow command, initialize output buffer for subsequent tokens. */
2502 static int
2503 parse_init(struct context *ctx, const struct token *token,
2504 	   const char *str, unsigned int len,
2505 	   void *buf, unsigned int size)
2506 {
2507 	struct buffer *out = buf;
2508 
2509 	/* Token name must match. */
2510 	if (parse_default(ctx, token, str, len, NULL, 0) < 0)
2511 		return -1;
2512 	/* Nothing else to do if there is no buffer. */
2513 	if (!out)
2514 		return len;
2515 	/* Make sure buffer is large enough. */
2516 	if (size < sizeof(*out))
2517 		return -1;
2518 	/* Initialize buffer. */
2519 	memset(out, 0x00, sizeof(*out));
2520 	memset((uint8_t *)out + sizeof(*out), 0x22, size - sizeof(*out));
2521 	ctx->objdata = 0;
2522 	ctx->object = out;
2523 	ctx->objmask = NULL;
2524 	return len;
2525 }
2526 
2527 /** Parse tokens for validate/create commands. */
2528 static int
2529 parse_vc(struct context *ctx, const struct token *token,
2530 	 const char *str, unsigned int len,
2531 	 void *buf, unsigned int size)
2532 {
2533 	struct buffer *out = buf;
2534 	uint8_t *data;
2535 	uint32_t data_size;
2536 
2537 	/* Token name must match. */
2538 	if (parse_default(ctx, token, str, len, NULL, 0) < 0)
2539 		return -1;
2540 	/* Nothing else to do if there is no buffer. */
2541 	if (!out)
2542 		return len;
2543 	if (!out->command) {
2544 		if (ctx->curr != VALIDATE && ctx->curr != CREATE)
2545 			return -1;
2546 		if (sizeof(*out) > size)
2547 			return -1;
2548 		out->command = ctx->curr;
2549 		ctx->objdata = 0;
2550 		ctx->object = out;
2551 		ctx->objmask = NULL;
2552 		out->args.vc.data = (uint8_t *)out + size;
2553 		return len;
2554 	}
2555 	ctx->objdata = 0;
2556 	ctx->object = &out->args.vc.attr;
2557 	ctx->objmask = NULL;
2558 	switch (ctx->curr) {
2559 	case GROUP:
2560 	case PRIORITY:
2561 		return len;
2562 	case INGRESS:
2563 		out->args.vc.attr.ingress = 1;
2564 		return len;
2565 	case EGRESS:
2566 		out->args.vc.attr.egress = 1;
2567 		return len;
2568 	case TRANSFER:
2569 		out->args.vc.attr.transfer = 1;
2570 		return len;
2571 	case PATTERN:
2572 		out->args.vc.pattern =
2573 			(void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
2574 					       sizeof(double));
2575 		ctx->object = out->args.vc.pattern;
2576 		ctx->objmask = NULL;
2577 		return len;
2578 	case ACTIONS:
2579 		out->args.vc.actions =
2580 			(void *)RTE_ALIGN_CEIL((uintptr_t)
2581 					       (out->args.vc.pattern +
2582 						out->args.vc.pattern_n),
2583 					       sizeof(double));
2584 		ctx->object = out->args.vc.actions;
2585 		ctx->objmask = NULL;
2586 		return len;
2587 	default:
2588 		if (!token->priv)
2589 			return -1;
2590 		break;
2591 	}
2592 	if (!out->args.vc.actions) {
2593 		const struct parse_item_priv *priv = token->priv;
2594 		struct rte_flow_item *item =
2595 			out->args.vc.pattern + out->args.vc.pattern_n;
2596 
2597 		data_size = priv->size * 3; /* spec, last, mask */
2598 		data = (void *)RTE_ALIGN_FLOOR((uintptr_t)
2599 					       (out->args.vc.data - data_size),
2600 					       sizeof(double));
2601 		if ((uint8_t *)item + sizeof(*item) > data)
2602 			return -1;
2603 		*item = (struct rte_flow_item){
2604 			.type = priv->type,
2605 		};
2606 		++out->args.vc.pattern_n;
2607 		ctx->object = item;
2608 		ctx->objmask = NULL;
2609 	} else {
2610 		const struct parse_action_priv *priv = token->priv;
2611 		struct rte_flow_action *action =
2612 			out->args.vc.actions + out->args.vc.actions_n;
2613 
2614 		data_size = priv->size; /* configuration */
2615 		data = (void *)RTE_ALIGN_FLOOR((uintptr_t)
2616 					       (out->args.vc.data - data_size),
2617 					       sizeof(double));
2618 		if ((uint8_t *)action + sizeof(*action) > data)
2619 			return -1;
2620 		*action = (struct rte_flow_action){
2621 			.type = priv->type,
2622 			.conf = data_size ? data : NULL,
2623 		};
2624 		++out->args.vc.actions_n;
2625 		ctx->object = action;
2626 		ctx->objmask = NULL;
2627 	}
2628 	memset(data, 0, data_size);
2629 	out->args.vc.data = data;
2630 	ctx->objdata = data_size;
2631 	return len;
2632 }
2633 
2634 /** Parse pattern item parameter type. */
2635 static int
2636 parse_vc_spec(struct context *ctx, const struct token *token,
2637 	      const char *str, unsigned int len,
2638 	      void *buf, unsigned int size)
2639 {
2640 	struct buffer *out = buf;
2641 	struct rte_flow_item *item;
2642 	uint32_t data_size;
2643 	int index;
2644 	int objmask = 0;
2645 
2646 	(void)size;
2647 	/* Token name must match. */
2648 	if (parse_default(ctx, token, str, len, NULL, 0) < 0)
2649 		return -1;
2650 	/* Parse parameter types. */
2651 	switch (ctx->curr) {
2652 		static const enum index prefix[] = NEXT_ENTRY(PREFIX);
2653 
2654 	case ITEM_PARAM_IS:
2655 		index = 0;
2656 		objmask = 1;
2657 		break;
2658 	case ITEM_PARAM_SPEC:
2659 		index = 0;
2660 		break;
2661 	case ITEM_PARAM_LAST:
2662 		index = 1;
2663 		break;
2664 	case ITEM_PARAM_PREFIX:
2665 		/* Modify next token to expect a prefix. */
2666 		if (ctx->next_num < 2)
2667 			return -1;
2668 		ctx->next[ctx->next_num - 2] = prefix;
2669 		/* Fall through. */
2670 	case ITEM_PARAM_MASK:
2671 		index = 2;
2672 		break;
2673 	default:
2674 		return -1;
2675 	}
2676 	/* Nothing else to do if there is no buffer. */
2677 	if (!out)
2678 		return len;
2679 	if (!out->args.vc.pattern_n)
2680 		return -1;
2681 	item = &out->args.vc.pattern[out->args.vc.pattern_n - 1];
2682 	data_size = ctx->objdata / 3; /* spec, last, mask */
2683 	/* Point to selected object. */
2684 	ctx->object = out->args.vc.data + (data_size * index);
2685 	if (objmask) {
2686 		ctx->objmask = out->args.vc.data + (data_size * 2); /* mask */
2687 		item->mask = ctx->objmask;
2688 	} else
2689 		ctx->objmask = NULL;
2690 	/* Update relevant item pointer. */
2691 	*((const void **[]){ &item->spec, &item->last, &item->mask })[index] =
2692 		ctx->object;
2693 	return len;
2694 }
2695 
2696 /** Parse action configuration field. */
2697 static int
2698 parse_vc_conf(struct context *ctx, const struct token *token,
2699 	      const char *str, unsigned int len,
2700 	      void *buf, unsigned int size)
2701 {
2702 	struct buffer *out = buf;
2703 
2704 	(void)size;
2705 	/* Token name must match. */
2706 	if (parse_default(ctx, token, str, len, NULL, 0) < 0)
2707 		return -1;
2708 	/* Nothing else to do if there is no buffer. */
2709 	if (!out)
2710 		return len;
2711 	/* Point to selected object. */
2712 	ctx->object = out->args.vc.data;
2713 	ctx->objmask = NULL;
2714 	return len;
2715 }
2716 
2717 /** Parse RSS action. */
2718 static int
2719 parse_vc_action_rss(struct context *ctx, const struct token *token,
2720 		    const char *str, unsigned int len,
2721 		    void *buf, unsigned int size)
2722 {
2723 	struct buffer *out = buf;
2724 	struct rte_flow_action *action;
2725 	struct action_rss_data *action_rss_data;
2726 	unsigned int i;
2727 	int ret;
2728 
2729 	ret = parse_vc(ctx, token, str, len, buf, size);
2730 	if (ret < 0)
2731 		return ret;
2732 	/* Nothing else to do if there is no buffer. */
2733 	if (!out)
2734 		return ret;
2735 	if (!out->args.vc.actions_n)
2736 		return -1;
2737 	action = &out->args.vc.actions[out->args.vc.actions_n - 1];
2738 	/* Point to selected object. */
2739 	ctx->object = out->args.vc.data;
2740 	ctx->objmask = NULL;
2741 	/* Set up default configuration. */
2742 	action_rss_data = ctx->object;
2743 	*action_rss_data = (struct action_rss_data){
2744 		.conf = (struct rte_flow_action_rss){
2745 			.func = RTE_ETH_HASH_FUNCTION_DEFAULT,
2746 			.level = 0,
2747 			.types = rss_hf,
2748 			.key_len = sizeof(action_rss_data->key),
2749 			.queue_num = RTE_MIN(nb_rxq, ACTION_RSS_QUEUE_NUM),
2750 			.key = action_rss_data->key,
2751 			.queue = action_rss_data->queue,
2752 		},
2753 		.key = "testpmd's default RSS hash key",
2754 		.queue = { 0 },
2755 	};
2756 	for (i = 0; i < action_rss_data->conf.queue_num; ++i)
2757 		action_rss_data->queue[i] = i;
2758 	if (!port_id_is_invalid(ctx->port, DISABLED_WARN) &&
2759 	    ctx->port != (portid_t)RTE_PORT_ALL) {
2760 		struct rte_eth_dev_info info;
2761 
2762 		rte_eth_dev_info_get(ctx->port, &info);
2763 		action_rss_data->conf.key_len =
2764 			RTE_MIN(sizeof(action_rss_data->key),
2765 				info.hash_key_size);
2766 	}
2767 	action->conf = &action_rss_data->conf;
2768 	return ret;
2769 }
2770 
2771 /**
2772  * Parse func field for RSS action.
2773  *
2774  * The RTE_ETH_HASH_FUNCTION_* value to assign is derived from the
2775  * ACTION_RSS_FUNC_* index that called this function.
2776  */
2777 static int
2778 parse_vc_action_rss_func(struct context *ctx, const struct token *token,
2779 			 const char *str, unsigned int len,
2780 			 void *buf, unsigned int size)
2781 {
2782 	struct action_rss_data *action_rss_data;
2783 	enum rte_eth_hash_function func;
2784 
2785 	(void)buf;
2786 	(void)size;
2787 	/* Token name must match. */
2788 	if (parse_default(ctx, token, str, len, NULL, 0) < 0)
2789 		return -1;
2790 	switch (ctx->curr) {
2791 	case ACTION_RSS_FUNC_DEFAULT:
2792 		func = RTE_ETH_HASH_FUNCTION_DEFAULT;
2793 		break;
2794 	case ACTION_RSS_FUNC_TOEPLITZ:
2795 		func = RTE_ETH_HASH_FUNCTION_TOEPLITZ;
2796 		break;
2797 	case ACTION_RSS_FUNC_SIMPLE_XOR:
2798 		func = RTE_ETH_HASH_FUNCTION_SIMPLE_XOR;
2799 		break;
2800 	default:
2801 		return -1;
2802 	}
2803 	if (!ctx->object)
2804 		return len;
2805 	action_rss_data = ctx->object;
2806 	action_rss_data->conf.func = func;
2807 	return len;
2808 }
2809 
2810 /**
2811  * Parse type field for RSS action.
2812  *
2813  * Valid tokens are type field names and the "end" token.
2814  */
2815 static int
2816 parse_vc_action_rss_type(struct context *ctx, const struct token *token,
2817 			  const char *str, unsigned int len,
2818 			  void *buf, unsigned int size)
2819 {
2820 	static const enum index next[] = NEXT_ENTRY(ACTION_RSS_TYPE);
2821 	struct action_rss_data *action_rss_data;
2822 	unsigned int i;
2823 
2824 	(void)token;
2825 	(void)buf;
2826 	(void)size;
2827 	if (ctx->curr != ACTION_RSS_TYPE)
2828 		return -1;
2829 	if (!(ctx->objdata >> 16) && ctx->object) {
2830 		action_rss_data = ctx->object;
2831 		action_rss_data->conf.types = 0;
2832 	}
2833 	if (!strcmp_partial("end", str, len)) {
2834 		ctx->objdata &= 0xffff;
2835 		return len;
2836 	}
2837 	for (i = 0; rss_type_table[i].str; ++i)
2838 		if (!strcmp_partial(rss_type_table[i].str, str, len))
2839 			break;
2840 	if (!rss_type_table[i].str)
2841 		return -1;
2842 	ctx->objdata = 1 << 16 | (ctx->objdata & 0xffff);
2843 	/* Repeat token. */
2844 	if (ctx->next_num == RTE_DIM(ctx->next))
2845 		return -1;
2846 	ctx->next[ctx->next_num++] = next;
2847 	if (!ctx->object)
2848 		return len;
2849 	action_rss_data = ctx->object;
2850 	action_rss_data->conf.types |= rss_type_table[i].rss_type;
2851 	return len;
2852 }
2853 
2854 /**
2855  * Parse queue field for RSS action.
2856  *
2857  * Valid tokens are queue indices and the "end" token.
2858  */
2859 static int
2860 parse_vc_action_rss_queue(struct context *ctx, const struct token *token,
2861 			  const char *str, unsigned int len,
2862 			  void *buf, unsigned int size)
2863 {
2864 	static const enum index next[] = NEXT_ENTRY(ACTION_RSS_QUEUE);
2865 	struct action_rss_data *action_rss_data;
2866 	int ret;
2867 	int i;
2868 
2869 	(void)token;
2870 	(void)buf;
2871 	(void)size;
2872 	if (ctx->curr != ACTION_RSS_QUEUE)
2873 		return -1;
2874 	i = ctx->objdata >> 16;
2875 	if (!strcmp_partial("end", str, len)) {
2876 		ctx->objdata &= 0xffff;
2877 		return len;
2878 	}
2879 	if (i >= ACTION_RSS_QUEUE_NUM)
2880 		return -1;
2881 	if (push_args(ctx,
2882 		      ARGS_ENTRY_ARB(offsetof(struct action_rss_data, queue) +
2883 				     i * sizeof(action_rss_data->queue[i]),
2884 				     sizeof(action_rss_data->queue[i]))))
2885 		return -1;
2886 	ret = parse_int(ctx, token, str, len, NULL, 0);
2887 	if (ret < 0) {
2888 		pop_args(ctx);
2889 		return -1;
2890 	}
2891 	++i;
2892 	ctx->objdata = i << 16 | (ctx->objdata & 0xffff);
2893 	/* Repeat token. */
2894 	if (ctx->next_num == RTE_DIM(ctx->next))
2895 		return -1;
2896 	ctx->next[ctx->next_num++] = next;
2897 	if (!ctx->object)
2898 		return len;
2899 	action_rss_data = ctx->object;
2900 	action_rss_data->conf.queue_num = i;
2901 	action_rss_data->conf.queue = i ? action_rss_data->queue : NULL;
2902 	return len;
2903 }
2904 
2905 /** Parse tokens for destroy command. */
2906 static int
2907 parse_destroy(struct context *ctx, const struct token *token,
2908 	      const char *str, unsigned int len,
2909 	      void *buf, unsigned int size)
2910 {
2911 	struct buffer *out = buf;
2912 
2913 	/* Token name must match. */
2914 	if (parse_default(ctx, token, str, len, NULL, 0) < 0)
2915 		return -1;
2916 	/* Nothing else to do if there is no buffer. */
2917 	if (!out)
2918 		return len;
2919 	if (!out->command) {
2920 		if (ctx->curr != DESTROY)
2921 			return -1;
2922 		if (sizeof(*out) > size)
2923 			return -1;
2924 		out->command = ctx->curr;
2925 		ctx->objdata = 0;
2926 		ctx->object = out;
2927 		ctx->objmask = NULL;
2928 		out->args.destroy.rule =
2929 			(void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
2930 					       sizeof(double));
2931 		return len;
2932 	}
2933 	if (((uint8_t *)(out->args.destroy.rule + out->args.destroy.rule_n) +
2934 	     sizeof(*out->args.destroy.rule)) > (uint8_t *)out + size)
2935 		return -1;
2936 	ctx->objdata = 0;
2937 	ctx->object = out->args.destroy.rule + out->args.destroy.rule_n++;
2938 	ctx->objmask = NULL;
2939 	return len;
2940 }
2941 
2942 /** Parse tokens for flush command. */
2943 static int
2944 parse_flush(struct context *ctx, const struct token *token,
2945 	    const char *str, unsigned int len,
2946 	    void *buf, unsigned int size)
2947 {
2948 	struct buffer *out = buf;
2949 
2950 	/* Token name must match. */
2951 	if (parse_default(ctx, token, str, len, NULL, 0) < 0)
2952 		return -1;
2953 	/* Nothing else to do if there is no buffer. */
2954 	if (!out)
2955 		return len;
2956 	if (!out->command) {
2957 		if (ctx->curr != FLUSH)
2958 			return -1;
2959 		if (sizeof(*out) > size)
2960 			return -1;
2961 		out->command = ctx->curr;
2962 		ctx->objdata = 0;
2963 		ctx->object = out;
2964 		ctx->objmask = NULL;
2965 	}
2966 	return len;
2967 }
2968 
2969 /** Parse tokens for query command. */
2970 static int
2971 parse_query(struct context *ctx, const struct token *token,
2972 	    const char *str, unsigned int len,
2973 	    void *buf, unsigned int size)
2974 {
2975 	struct buffer *out = buf;
2976 
2977 	/* Token name must match. */
2978 	if (parse_default(ctx, token, str, len, NULL, 0) < 0)
2979 		return -1;
2980 	/* Nothing else to do if there is no buffer. */
2981 	if (!out)
2982 		return len;
2983 	if (!out->command) {
2984 		if (ctx->curr != QUERY)
2985 			return -1;
2986 		if (sizeof(*out) > size)
2987 			return -1;
2988 		out->command = ctx->curr;
2989 		ctx->objdata = 0;
2990 		ctx->object = out;
2991 		ctx->objmask = NULL;
2992 	}
2993 	return len;
2994 }
2995 
2996 /** Parse action names. */
2997 static int
2998 parse_action(struct context *ctx, const struct token *token,
2999 	     const char *str, unsigned int len,
3000 	     void *buf, unsigned int size)
3001 {
3002 	struct buffer *out = buf;
3003 	const struct arg *arg = pop_args(ctx);
3004 	unsigned int i;
3005 
3006 	(void)size;
3007 	/* Argument is expected. */
3008 	if (!arg)
3009 		return -1;
3010 	/* Parse action name. */
3011 	for (i = 0; next_action[i]; ++i) {
3012 		const struct parse_action_priv *priv;
3013 
3014 		token = &token_list[next_action[i]];
3015 		if (strcmp_partial(token->name, str, len))
3016 			continue;
3017 		priv = token->priv;
3018 		if (!priv)
3019 			goto error;
3020 		if (out)
3021 			memcpy((uint8_t *)ctx->object + arg->offset,
3022 			       &priv->type,
3023 			       arg->size);
3024 		return len;
3025 	}
3026 error:
3027 	push_args(ctx, arg);
3028 	return -1;
3029 }
3030 
3031 /** Parse tokens for list command. */
3032 static int
3033 parse_list(struct context *ctx, const struct token *token,
3034 	   const char *str, unsigned int len,
3035 	   void *buf, unsigned int size)
3036 {
3037 	struct buffer *out = buf;
3038 
3039 	/* Token name must match. */
3040 	if (parse_default(ctx, token, str, len, NULL, 0) < 0)
3041 		return -1;
3042 	/* Nothing else to do if there is no buffer. */
3043 	if (!out)
3044 		return len;
3045 	if (!out->command) {
3046 		if (ctx->curr != LIST)
3047 			return -1;
3048 		if (sizeof(*out) > size)
3049 			return -1;
3050 		out->command = ctx->curr;
3051 		ctx->objdata = 0;
3052 		ctx->object = out;
3053 		ctx->objmask = NULL;
3054 		out->args.list.group =
3055 			(void *)RTE_ALIGN_CEIL((uintptr_t)(out + 1),
3056 					       sizeof(double));
3057 		return len;
3058 	}
3059 	if (((uint8_t *)(out->args.list.group + out->args.list.group_n) +
3060 	     sizeof(*out->args.list.group)) > (uint8_t *)out + size)
3061 		return -1;
3062 	ctx->objdata = 0;
3063 	ctx->object = out->args.list.group + out->args.list.group_n++;
3064 	ctx->objmask = NULL;
3065 	return len;
3066 }
3067 
3068 /** Parse tokens for isolate command. */
3069 static int
3070 parse_isolate(struct context *ctx, const struct token *token,
3071 	      const char *str, unsigned int len,
3072 	      void *buf, unsigned int size)
3073 {
3074 	struct buffer *out = buf;
3075 
3076 	/* Token name must match. */
3077 	if (parse_default(ctx, token, str, len, NULL, 0) < 0)
3078 		return -1;
3079 	/* Nothing else to do if there is no buffer. */
3080 	if (!out)
3081 		return len;
3082 	if (!out->command) {
3083 		if (ctx->curr != ISOLATE)
3084 			return -1;
3085 		if (sizeof(*out) > size)
3086 			return -1;
3087 		out->command = ctx->curr;
3088 		ctx->objdata = 0;
3089 		ctx->object = out;
3090 		ctx->objmask = NULL;
3091 	}
3092 	return len;
3093 }
3094 
3095 /**
3096  * Parse signed/unsigned integers 8 to 64-bit long.
3097  *
3098  * Last argument (ctx->args) is retrieved to determine integer type and
3099  * storage location.
3100  */
3101 static int
3102 parse_int(struct context *ctx, const struct token *token,
3103 	  const char *str, unsigned int len,
3104 	  void *buf, unsigned int size)
3105 {
3106 	const struct arg *arg = pop_args(ctx);
3107 	uintmax_t u;
3108 	char *end;
3109 
3110 	(void)token;
3111 	/* Argument is expected. */
3112 	if (!arg)
3113 		return -1;
3114 	errno = 0;
3115 	u = arg->sign ?
3116 		(uintmax_t)strtoimax(str, &end, 0) :
3117 		strtoumax(str, &end, 0);
3118 	if (errno || (size_t)(end - str) != len)
3119 		goto error;
3120 	if (arg->bounded &&
3121 	    ((arg->sign && ((intmax_t)u < (intmax_t)arg->min ||
3122 			    (intmax_t)u > (intmax_t)arg->max)) ||
3123 	     (!arg->sign && (u < arg->min || u > arg->max))))
3124 		goto error;
3125 	if (!ctx->object)
3126 		return len;
3127 	if (arg->mask) {
3128 		if (!arg_entry_bf_fill(ctx->object, u, arg) ||
3129 		    !arg_entry_bf_fill(ctx->objmask, -1, arg))
3130 			goto error;
3131 		return len;
3132 	}
3133 	buf = (uint8_t *)ctx->object + arg->offset;
3134 	size = arg->size;
3135 objmask:
3136 	switch (size) {
3137 	case sizeof(uint8_t):
3138 		*(uint8_t *)buf = u;
3139 		break;
3140 	case sizeof(uint16_t):
3141 		*(uint16_t *)buf = arg->hton ? rte_cpu_to_be_16(u) : u;
3142 		break;
3143 	case sizeof(uint8_t [3]):
3144 #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
3145 		if (!arg->hton) {
3146 			((uint8_t *)buf)[0] = u;
3147 			((uint8_t *)buf)[1] = u >> 8;
3148 			((uint8_t *)buf)[2] = u >> 16;
3149 			break;
3150 		}
3151 #endif
3152 		((uint8_t *)buf)[0] = u >> 16;
3153 		((uint8_t *)buf)[1] = u >> 8;
3154 		((uint8_t *)buf)[2] = u;
3155 		break;
3156 	case sizeof(uint32_t):
3157 		*(uint32_t *)buf = arg->hton ? rte_cpu_to_be_32(u) : u;
3158 		break;
3159 	case sizeof(uint64_t):
3160 		*(uint64_t *)buf = arg->hton ? rte_cpu_to_be_64(u) : u;
3161 		break;
3162 	default:
3163 		goto error;
3164 	}
3165 	if (ctx->objmask && buf != (uint8_t *)ctx->objmask + arg->offset) {
3166 		u = -1;
3167 		buf = (uint8_t *)ctx->objmask + arg->offset;
3168 		goto objmask;
3169 	}
3170 	return len;
3171 error:
3172 	push_args(ctx, arg);
3173 	return -1;
3174 }
3175 
3176 /**
3177  * Parse a string.
3178  *
3179  * Three arguments (ctx->args) are retrieved from the stack to store data,
3180  * its actual length and address (in that order).
3181  */
3182 static int
3183 parse_string(struct context *ctx, const struct token *token,
3184 	     const char *str, unsigned int len,
3185 	     void *buf, unsigned int size)
3186 {
3187 	const struct arg *arg_data = pop_args(ctx);
3188 	const struct arg *arg_len = pop_args(ctx);
3189 	const struct arg *arg_addr = pop_args(ctx);
3190 	char tmp[16]; /* Ought to be enough. */
3191 	int ret;
3192 
3193 	/* Arguments are expected. */
3194 	if (!arg_data)
3195 		return -1;
3196 	if (!arg_len) {
3197 		push_args(ctx, arg_data);
3198 		return -1;
3199 	}
3200 	if (!arg_addr) {
3201 		push_args(ctx, arg_len);
3202 		push_args(ctx, arg_data);
3203 		return -1;
3204 	}
3205 	size = arg_data->size;
3206 	/* Bit-mask fill is not supported. */
3207 	if (arg_data->mask || size < len)
3208 		goto error;
3209 	if (!ctx->object)
3210 		return len;
3211 	/* Let parse_int() fill length information first. */
3212 	ret = snprintf(tmp, sizeof(tmp), "%u", len);
3213 	if (ret < 0)
3214 		goto error;
3215 	push_args(ctx, arg_len);
3216 	ret = parse_int(ctx, token, tmp, ret, NULL, 0);
3217 	if (ret < 0) {
3218 		pop_args(ctx);
3219 		goto error;
3220 	}
3221 	buf = (uint8_t *)ctx->object + arg_data->offset;
3222 	/* Output buffer is not necessarily NUL-terminated. */
3223 	memcpy(buf, str, len);
3224 	memset((uint8_t *)buf + len, 0x00, size - len);
3225 	if (ctx->objmask)
3226 		memset((uint8_t *)ctx->objmask + arg_data->offset, 0xff, len);
3227 	/* Save address if requested. */
3228 	if (arg_addr->size) {
3229 		memcpy((uint8_t *)ctx->object + arg_addr->offset,
3230 		       (void *[]){
3231 			(uint8_t *)ctx->object + arg_data->offset
3232 		       },
3233 		       arg_addr->size);
3234 		if (ctx->objmask)
3235 			memcpy((uint8_t *)ctx->objmask + arg_addr->offset,
3236 			       (void *[]){
3237 				(uint8_t *)ctx->objmask + arg_data->offset
3238 			       },
3239 			       arg_addr->size);
3240 	}
3241 	return len;
3242 error:
3243 	push_args(ctx, arg_addr);
3244 	push_args(ctx, arg_len);
3245 	push_args(ctx, arg_data);
3246 	return -1;
3247 }
3248 
3249 /**
3250  * Parse a MAC address.
3251  *
3252  * Last argument (ctx->args) is retrieved to determine storage size and
3253  * location.
3254  */
3255 static int
3256 parse_mac_addr(struct context *ctx, const struct token *token,
3257 	       const char *str, unsigned int len,
3258 	       void *buf, unsigned int size)
3259 {
3260 	const struct arg *arg = pop_args(ctx);
3261 	struct ether_addr tmp;
3262 	int ret;
3263 
3264 	(void)token;
3265 	/* Argument is expected. */
3266 	if (!arg)
3267 		return -1;
3268 	size = arg->size;
3269 	/* Bit-mask fill is not supported. */
3270 	if (arg->mask || size != sizeof(tmp))
3271 		goto error;
3272 	/* Only network endian is supported. */
3273 	if (!arg->hton)
3274 		goto error;
3275 	ret = cmdline_parse_etheraddr(NULL, str, &tmp, size);
3276 	if (ret < 0 || (unsigned int)ret != len)
3277 		goto error;
3278 	if (!ctx->object)
3279 		return len;
3280 	buf = (uint8_t *)ctx->object + arg->offset;
3281 	memcpy(buf, &tmp, size);
3282 	if (ctx->objmask)
3283 		memset((uint8_t *)ctx->objmask + arg->offset, 0xff, size);
3284 	return len;
3285 error:
3286 	push_args(ctx, arg);
3287 	return -1;
3288 }
3289 
3290 /**
3291  * Parse an IPv4 address.
3292  *
3293  * Last argument (ctx->args) is retrieved to determine storage size and
3294  * location.
3295  */
3296 static int
3297 parse_ipv4_addr(struct context *ctx, const struct token *token,
3298 		const char *str, unsigned int len,
3299 		void *buf, unsigned int size)
3300 {
3301 	const struct arg *arg = pop_args(ctx);
3302 	char str2[len + 1];
3303 	struct in_addr tmp;
3304 	int ret;
3305 
3306 	/* Argument is expected. */
3307 	if (!arg)
3308 		return -1;
3309 	size = arg->size;
3310 	/* Bit-mask fill is not supported. */
3311 	if (arg->mask || size != sizeof(tmp))
3312 		goto error;
3313 	/* Only network endian is supported. */
3314 	if (!arg->hton)
3315 		goto error;
3316 	memcpy(str2, str, len);
3317 	str2[len] = '\0';
3318 	ret = inet_pton(AF_INET, str2, &tmp);
3319 	if (ret != 1) {
3320 		/* Attempt integer parsing. */
3321 		push_args(ctx, arg);
3322 		return parse_int(ctx, token, str, len, buf, size);
3323 	}
3324 	if (!ctx->object)
3325 		return len;
3326 	buf = (uint8_t *)ctx->object + arg->offset;
3327 	memcpy(buf, &tmp, size);
3328 	if (ctx->objmask)
3329 		memset((uint8_t *)ctx->objmask + arg->offset, 0xff, size);
3330 	return len;
3331 error:
3332 	push_args(ctx, arg);
3333 	return -1;
3334 }
3335 
3336 /**
3337  * Parse an IPv6 address.
3338  *
3339  * Last argument (ctx->args) is retrieved to determine storage size and
3340  * location.
3341  */
3342 static int
3343 parse_ipv6_addr(struct context *ctx, const struct token *token,
3344 		const char *str, unsigned int len,
3345 		void *buf, unsigned int size)
3346 {
3347 	const struct arg *arg = pop_args(ctx);
3348 	char str2[len + 1];
3349 	struct in6_addr tmp;
3350 	int ret;
3351 
3352 	(void)token;
3353 	/* Argument is expected. */
3354 	if (!arg)
3355 		return -1;
3356 	size = arg->size;
3357 	/* Bit-mask fill is not supported. */
3358 	if (arg->mask || size != sizeof(tmp))
3359 		goto error;
3360 	/* Only network endian is supported. */
3361 	if (!arg->hton)
3362 		goto error;
3363 	memcpy(str2, str, len);
3364 	str2[len] = '\0';
3365 	ret = inet_pton(AF_INET6, str2, &tmp);
3366 	if (ret != 1)
3367 		goto error;
3368 	if (!ctx->object)
3369 		return len;
3370 	buf = (uint8_t *)ctx->object + arg->offset;
3371 	memcpy(buf, &tmp, size);
3372 	if (ctx->objmask)
3373 		memset((uint8_t *)ctx->objmask + arg->offset, 0xff, size);
3374 	return len;
3375 error:
3376 	push_args(ctx, arg);
3377 	return -1;
3378 }
3379 
3380 /** Boolean values (even indices stand for false). */
3381 static const char *const boolean_name[] = {
3382 	"0", "1",
3383 	"false", "true",
3384 	"no", "yes",
3385 	"N", "Y",
3386 	"off", "on",
3387 	NULL,
3388 };
3389 
3390 /**
3391  * Parse a boolean value.
3392  *
3393  * Last argument (ctx->args) is retrieved to determine storage size and
3394  * location.
3395  */
3396 static int
3397 parse_boolean(struct context *ctx, const struct token *token,
3398 	      const char *str, unsigned int len,
3399 	      void *buf, unsigned int size)
3400 {
3401 	const struct arg *arg = pop_args(ctx);
3402 	unsigned int i;
3403 	int ret;
3404 
3405 	/* Argument is expected. */
3406 	if (!arg)
3407 		return -1;
3408 	for (i = 0; boolean_name[i]; ++i)
3409 		if (!strcmp_partial(boolean_name[i], str, len))
3410 			break;
3411 	/* Process token as integer. */
3412 	if (boolean_name[i])
3413 		str = i & 1 ? "1" : "0";
3414 	push_args(ctx, arg);
3415 	ret = parse_int(ctx, token, str, strlen(str), buf, size);
3416 	return ret > 0 ? (int)len : ret;
3417 }
3418 
3419 /** Parse port and update context. */
3420 static int
3421 parse_port(struct context *ctx, const struct token *token,
3422 	   const char *str, unsigned int len,
3423 	   void *buf, unsigned int size)
3424 {
3425 	struct buffer *out = &(struct buffer){ .port = 0 };
3426 	int ret;
3427 
3428 	if (buf)
3429 		out = buf;
3430 	else {
3431 		ctx->objdata = 0;
3432 		ctx->object = out;
3433 		ctx->objmask = NULL;
3434 		size = sizeof(*out);
3435 	}
3436 	ret = parse_int(ctx, token, str, len, out, size);
3437 	if (ret >= 0)
3438 		ctx->port = out->port;
3439 	if (!buf)
3440 		ctx->object = NULL;
3441 	return ret;
3442 }
3443 
3444 /** No completion. */
3445 static int
3446 comp_none(struct context *ctx, const struct token *token,
3447 	  unsigned int ent, char *buf, unsigned int size)
3448 {
3449 	(void)ctx;
3450 	(void)token;
3451 	(void)ent;
3452 	(void)buf;
3453 	(void)size;
3454 	return 0;
3455 }
3456 
3457 /** Complete boolean values. */
3458 static int
3459 comp_boolean(struct context *ctx, const struct token *token,
3460 	     unsigned int ent, char *buf, unsigned int size)
3461 {
3462 	unsigned int i;
3463 
3464 	(void)ctx;
3465 	(void)token;
3466 	for (i = 0; boolean_name[i]; ++i)
3467 		if (buf && i == ent)
3468 			return snprintf(buf, size, "%s", boolean_name[i]);
3469 	if (buf)
3470 		return -1;
3471 	return i;
3472 }
3473 
3474 /** Complete action names. */
3475 static int
3476 comp_action(struct context *ctx, const struct token *token,
3477 	    unsigned int ent, char *buf, unsigned int size)
3478 {
3479 	unsigned int i;
3480 
3481 	(void)ctx;
3482 	(void)token;
3483 	for (i = 0; next_action[i]; ++i)
3484 		if (buf && i == ent)
3485 			return snprintf(buf, size, "%s",
3486 					token_list[next_action[i]].name);
3487 	if (buf)
3488 		return -1;
3489 	return i;
3490 }
3491 
3492 /** Complete available ports. */
3493 static int
3494 comp_port(struct context *ctx, const struct token *token,
3495 	  unsigned int ent, char *buf, unsigned int size)
3496 {
3497 	unsigned int i = 0;
3498 	portid_t p;
3499 
3500 	(void)ctx;
3501 	(void)token;
3502 	RTE_ETH_FOREACH_DEV(p) {
3503 		if (buf && i == ent)
3504 			return snprintf(buf, size, "%u", p);
3505 		++i;
3506 	}
3507 	if (buf)
3508 		return -1;
3509 	return i;
3510 }
3511 
3512 /** Complete available rule IDs. */
3513 static int
3514 comp_rule_id(struct context *ctx, const struct token *token,
3515 	     unsigned int ent, char *buf, unsigned int size)
3516 {
3517 	unsigned int i = 0;
3518 	struct rte_port *port;
3519 	struct port_flow *pf;
3520 
3521 	(void)token;
3522 	if (port_id_is_invalid(ctx->port, DISABLED_WARN) ||
3523 	    ctx->port == (portid_t)RTE_PORT_ALL)
3524 		return -1;
3525 	port = &ports[ctx->port];
3526 	for (pf = port->flow_list; pf != NULL; pf = pf->next) {
3527 		if (buf && i == ent)
3528 			return snprintf(buf, size, "%u", pf->id);
3529 		++i;
3530 	}
3531 	if (buf)
3532 		return -1;
3533 	return i;
3534 }
3535 
3536 /** Complete type field for RSS action. */
3537 static int
3538 comp_vc_action_rss_type(struct context *ctx, const struct token *token,
3539 			unsigned int ent, char *buf, unsigned int size)
3540 {
3541 	unsigned int i;
3542 
3543 	(void)ctx;
3544 	(void)token;
3545 	for (i = 0; rss_type_table[i].str; ++i)
3546 		;
3547 	if (!buf)
3548 		return i + 1;
3549 	if (ent < i)
3550 		return snprintf(buf, size, "%s", rss_type_table[ent].str);
3551 	if (ent == i)
3552 		return snprintf(buf, size, "end");
3553 	return -1;
3554 }
3555 
3556 /** Complete queue field for RSS action. */
3557 static int
3558 comp_vc_action_rss_queue(struct context *ctx, const struct token *token,
3559 			 unsigned int ent, char *buf, unsigned int size)
3560 {
3561 	(void)ctx;
3562 	(void)token;
3563 	if (!buf)
3564 		return nb_rxq + 1;
3565 	if (ent < nb_rxq)
3566 		return snprintf(buf, size, "%u", ent);
3567 	if (ent == nb_rxq)
3568 		return snprintf(buf, size, "end");
3569 	return -1;
3570 }
3571 
3572 /** Internal context. */
3573 static struct context cmd_flow_context;
3574 
3575 /** Global parser instance (cmdline API). */
3576 cmdline_parse_inst_t cmd_flow;
3577 
3578 /** Initialize context. */
3579 static void
3580 cmd_flow_context_init(struct context *ctx)
3581 {
3582 	/* A full memset() is not necessary. */
3583 	ctx->curr = ZERO;
3584 	ctx->prev = ZERO;
3585 	ctx->next_num = 0;
3586 	ctx->args_num = 0;
3587 	ctx->eol = 0;
3588 	ctx->last = 0;
3589 	ctx->port = 0;
3590 	ctx->objdata = 0;
3591 	ctx->object = NULL;
3592 	ctx->objmask = NULL;
3593 }
3594 
3595 /** Parse a token (cmdline API). */
3596 static int
3597 cmd_flow_parse(cmdline_parse_token_hdr_t *hdr, const char *src, void *result,
3598 	       unsigned int size)
3599 {
3600 	struct context *ctx = &cmd_flow_context;
3601 	const struct token *token;
3602 	const enum index *list;
3603 	int len;
3604 	int i;
3605 
3606 	(void)hdr;
3607 	token = &token_list[ctx->curr];
3608 	/* Check argument length. */
3609 	ctx->eol = 0;
3610 	ctx->last = 1;
3611 	for (len = 0; src[len]; ++len)
3612 		if (src[len] == '#' || isspace(src[len]))
3613 			break;
3614 	if (!len)
3615 		return -1;
3616 	/* Last argument and EOL detection. */
3617 	for (i = len; src[i]; ++i)
3618 		if (src[i] == '#' || src[i] == '\r' || src[i] == '\n')
3619 			break;
3620 		else if (!isspace(src[i])) {
3621 			ctx->last = 0;
3622 			break;
3623 		}
3624 	for (; src[i]; ++i)
3625 		if (src[i] == '\r' || src[i] == '\n') {
3626 			ctx->eol = 1;
3627 			break;
3628 		}
3629 	/* Initialize context if necessary. */
3630 	if (!ctx->next_num) {
3631 		if (!token->next)
3632 			return 0;
3633 		ctx->next[ctx->next_num++] = token->next[0];
3634 	}
3635 	/* Process argument through candidates. */
3636 	ctx->prev = ctx->curr;
3637 	list = ctx->next[ctx->next_num - 1];
3638 	for (i = 0; list[i]; ++i) {
3639 		const struct token *next = &token_list[list[i]];
3640 		int tmp;
3641 
3642 		ctx->curr = list[i];
3643 		if (next->call)
3644 			tmp = next->call(ctx, next, src, len, result, size);
3645 		else
3646 			tmp = parse_default(ctx, next, src, len, result, size);
3647 		if (tmp == -1 || tmp != len)
3648 			continue;
3649 		token = next;
3650 		break;
3651 	}
3652 	if (!list[i])
3653 		return -1;
3654 	--ctx->next_num;
3655 	/* Push subsequent tokens if any. */
3656 	if (token->next)
3657 		for (i = 0; token->next[i]; ++i) {
3658 			if (ctx->next_num == RTE_DIM(ctx->next))
3659 				return -1;
3660 			ctx->next[ctx->next_num++] = token->next[i];
3661 		}
3662 	/* Push arguments if any. */
3663 	if (token->args)
3664 		for (i = 0; token->args[i]; ++i) {
3665 			if (ctx->args_num == RTE_DIM(ctx->args))
3666 				return -1;
3667 			ctx->args[ctx->args_num++] = token->args[i];
3668 		}
3669 	return len;
3670 }
3671 
3672 /** Return number of completion entries (cmdline API). */
3673 static int
3674 cmd_flow_complete_get_nb(cmdline_parse_token_hdr_t *hdr)
3675 {
3676 	struct context *ctx = &cmd_flow_context;
3677 	const struct token *token = &token_list[ctx->curr];
3678 	const enum index *list;
3679 	int i;
3680 
3681 	(void)hdr;
3682 	/* Count number of tokens in current list. */
3683 	if (ctx->next_num)
3684 		list = ctx->next[ctx->next_num - 1];
3685 	else
3686 		list = token->next[0];
3687 	for (i = 0; list[i]; ++i)
3688 		;
3689 	if (!i)
3690 		return 0;
3691 	/*
3692 	 * If there is a single token, use its completion callback, otherwise
3693 	 * return the number of entries.
3694 	 */
3695 	token = &token_list[list[0]];
3696 	if (i == 1 && token->comp) {
3697 		/* Save index for cmd_flow_get_help(). */
3698 		ctx->prev = list[0];
3699 		return token->comp(ctx, token, 0, NULL, 0);
3700 	}
3701 	return i;
3702 }
3703 
3704 /** Return a completion entry (cmdline API). */
3705 static int
3706 cmd_flow_complete_get_elt(cmdline_parse_token_hdr_t *hdr, int index,
3707 			  char *dst, unsigned int size)
3708 {
3709 	struct context *ctx = &cmd_flow_context;
3710 	const struct token *token = &token_list[ctx->curr];
3711 	const enum index *list;
3712 	int i;
3713 
3714 	(void)hdr;
3715 	/* Count number of tokens in current list. */
3716 	if (ctx->next_num)
3717 		list = ctx->next[ctx->next_num - 1];
3718 	else
3719 		list = token->next[0];
3720 	for (i = 0; list[i]; ++i)
3721 		;
3722 	if (!i)
3723 		return -1;
3724 	/* If there is a single token, use its completion callback. */
3725 	token = &token_list[list[0]];
3726 	if (i == 1 && token->comp) {
3727 		/* Save index for cmd_flow_get_help(). */
3728 		ctx->prev = list[0];
3729 		return token->comp(ctx, token, index, dst, size) < 0 ? -1 : 0;
3730 	}
3731 	/* Otherwise make sure the index is valid and use defaults. */
3732 	if (index >= i)
3733 		return -1;
3734 	token = &token_list[list[index]];
3735 	snprintf(dst, size, "%s", token->name);
3736 	/* Save index for cmd_flow_get_help(). */
3737 	ctx->prev = list[index];
3738 	return 0;
3739 }
3740 
3741 /** Populate help strings for current token (cmdline API). */
3742 static int
3743 cmd_flow_get_help(cmdline_parse_token_hdr_t *hdr, char *dst, unsigned int size)
3744 {
3745 	struct context *ctx = &cmd_flow_context;
3746 	const struct token *token = &token_list[ctx->prev];
3747 
3748 	(void)hdr;
3749 	if (!size)
3750 		return -1;
3751 	/* Set token type and update global help with details. */
3752 	snprintf(dst, size, "%s", (token->type ? token->type : "TOKEN"));
3753 	if (token->help)
3754 		cmd_flow.help_str = token->help;
3755 	else
3756 		cmd_flow.help_str = token->name;
3757 	return 0;
3758 }
3759 
3760 /** Token definition template (cmdline API). */
3761 static struct cmdline_token_hdr cmd_flow_token_hdr = {
3762 	.ops = &(struct cmdline_token_ops){
3763 		.parse = cmd_flow_parse,
3764 		.complete_get_nb = cmd_flow_complete_get_nb,
3765 		.complete_get_elt = cmd_flow_complete_get_elt,
3766 		.get_help = cmd_flow_get_help,
3767 	},
3768 	.offset = 0,
3769 };
3770 
3771 /** Populate the next dynamic token. */
3772 static void
3773 cmd_flow_tok(cmdline_parse_token_hdr_t **hdr,
3774 	     cmdline_parse_token_hdr_t **hdr_inst)
3775 {
3776 	struct context *ctx = &cmd_flow_context;
3777 
3778 	/* Always reinitialize context before requesting the first token. */
3779 	if (!(hdr_inst - cmd_flow.tokens))
3780 		cmd_flow_context_init(ctx);
3781 	/* Return NULL when no more tokens are expected. */
3782 	if (!ctx->next_num && ctx->curr) {
3783 		*hdr = NULL;
3784 		return;
3785 	}
3786 	/* Determine if command should end here. */
3787 	if (ctx->eol && ctx->last && ctx->next_num) {
3788 		const enum index *list = ctx->next[ctx->next_num - 1];
3789 		int i;
3790 
3791 		for (i = 0; list[i]; ++i) {
3792 			if (list[i] != END)
3793 				continue;
3794 			*hdr = NULL;
3795 			return;
3796 		}
3797 	}
3798 	*hdr = &cmd_flow_token_hdr;
3799 }
3800 
3801 /** Dispatch parsed buffer to function calls. */
3802 static void
3803 cmd_flow_parsed(const struct buffer *in)
3804 {
3805 	switch (in->command) {
3806 	case VALIDATE:
3807 		port_flow_validate(in->port, &in->args.vc.attr,
3808 				   in->args.vc.pattern, in->args.vc.actions);
3809 		break;
3810 	case CREATE:
3811 		port_flow_create(in->port, &in->args.vc.attr,
3812 				 in->args.vc.pattern, in->args.vc.actions);
3813 		break;
3814 	case DESTROY:
3815 		port_flow_destroy(in->port, in->args.destroy.rule_n,
3816 				  in->args.destroy.rule);
3817 		break;
3818 	case FLUSH:
3819 		port_flow_flush(in->port);
3820 		break;
3821 	case QUERY:
3822 		port_flow_query(in->port, in->args.query.rule,
3823 				in->args.query.action);
3824 		break;
3825 	case LIST:
3826 		port_flow_list(in->port, in->args.list.group_n,
3827 			       in->args.list.group);
3828 		break;
3829 	case ISOLATE:
3830 		port_flow_isolate(in->port, in->args.isolate.set);
3831 		break;
3832 	default:
3833 		break;
3834 	}
3835 }
3836 
3837 /** Token generator and output processing callback (cmdline API). */
3838 static void
3839 cmd_flow_cb(void *arg0, struct cmdline *cl, void *arg2)
3840 {
3841 	if (cl == NULL)
3842 		cmd_flow_tok(arg0, arg2);
3843 	else
3844 		cmd_flow_parsed(arg0);
3845 }
3846 
3847 /** Global parser instance (cmdline API). */
3848 cmdline_parse_inst_t cmd_flow = {
3849 	.f = cmd_flow_cb,
3850 	.data = NULL, /**< Unused. */
3851 	.help_str = NULL, /**< Updated by cmd_flow_get_help(). */
3852 	.tokens = {
3853 		NULL,
3854 	}, /**< Tokens are returned by cmd_flow_tok(). */
3855 };
3856