2 * Testing shim and API examples for the new CLI backend.
4 * This unit defines a number of commands in the old engine that can
5 * be used to test and interact with the new engine.
7 * Copyright (C) 2016 Cumulus Networks, Inc.
9 * This file is part of GNU Zebra.
11 * GNU Zebra is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the
13 * Free Software Foundation; either version 2, or (at your option) any
16 * GNU Zebra is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
21 * You should have received a copy of the GNU General Public License along
22 * with this program; see the file COPYING; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
33 #include "command_match.h"
35 #define GRAMMAR_STR "CLI grammar sandbox\n"
37 DEFINE_MTYPE_STATIC(LIB
, CMD_TOKENS
, "Command desc");
40 void grammar_sandbox_init(void);
41 static void pretty_print_graph(struct vty
*vty
, struct graph_node
*, int, int,
42 struct graph_node
**, size_t);
43 static void init_cmdgraph(struct vty
*, struct graph
**);
45 /** shim interface commands **/
46 static struct graph
*nodegraph
= NULL
, *nodegraph_free
= NULL
;
48 #define check_nodegraph() \
51 vty_out(vty, "nodegraph not initialized\n"); \
58 "grammar parse LINE...",
61 "command to pass to new parser\n")
66 // make a string from tokenized command line
67 char *command
= argv_concat(argv
, argc
, idx_command
);
69 // create cmd_element for parser
70 struct cmd_element
*cmd
=
71 XCALLOC(MTYPE_CMD_TOKENS
, sizeof(struct cmd_element
));
72 cmd
->string
= command
;
74 "0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n";
77 // parse the command and install it into the command graph
78 struct graph
*graph
= graph_new();
79 struct cmd_token
*token
=
80 cmd_token_new(START_TKN
, CMD_ATTR_NORMAL
, NULL
, NULL
);
81 graph_new_node(graph
, token
, (void (*)(void *)) & cmd_token_del
);
83 cmd_graph_parse(graph
, cmd
);
84 cmd_graph_merge(nodegraph
, graph
, +1);
89 DEFUN (grammar_test_complete
,
90 grammar_test_complete_cmd
,
91 "grammar complete COMMAND...",
93 "attempt to complete input on DFA\n"
94 "command to complete\n")
99 char *cmdstr
= argv_concat(argv
, argc
, idx_command
);
103 vector command
= cmd_make_strvec(cmdstr
);
105 XFREE(MTYPE_TMP
, cmdstr
);
109 // generate completions of user input
110 struct list
*completions
;
111 enum matcher_rv result
=
112 command_complete(nodegraph
, command
, &completions
);
114 // print completions or relevant error message
115 if (!MATCHER_ERROR(result
)) {
116 vector comps
= completions_to_vec(completions
);
117 struct cmd_token
*tkn
;
119 // calculate length of longest tkn->text in completions
120 unsigned int width
= 0, i
= 0;
121 for (i
= 0; i
< vector_active(comps
); i
++) {
122 tkn
= vector_slot(comps
, i
);
123 unsigned int len
= strlen(tkn
->text
);
124 width
= len
> width
? len
: width
;
128 for (i
= 0; i
< vector_active(comps
); i
++) {
129 tkn
= vector_slot(comps
, i
);
130 vty_out(vty
, " %-*s %s\n", width
, tkn
->text
,
134 for (i
= 0; i
< vector_active(comps
); i
++)
136 (struct cmd_token
*)vector_slot(comps
, i
));
139 vty_out(vty
, "%% No match\n");
142 list_delete(&completions
);
143 cmd_free_strvec(command
);
144 XFREE(MTYPE_TMP
, cmdstr
);
149 DEFUN (grammar_test_match
,
150 grammar_test_match_cmd
,
151 "grammar match COMMAND...",
153 "attempt to match input on DFA\n"
154 "command to match\n")
159 if (argv
[2]->arg
[0] == '#')
162 char *cmdstr
= argv_concat(argv
, argc
, idx_command
);
165 vector command
= cmd_make_strvec(cmdstr
);
167 XFREE(MTYPE_TMP
, cmdstr
);
171 struct list
*argvv
= NULL
;
172 const struct cmd_element
*element
= NULL
;
173 enum matcher_rv result
=
174 command_match(nodegraph
, command
, &argvv
, &element
);
176 // print completions or relevant error message
178 vty_out(vty
, "Matched: %s\n", element
->string
);
180 struct cmd_token
*token
;
181 for (ALL_LIST_ELEMENTS_RO(argvv
, ln
, token
))
182 vty_out(vty
, "%s -- %s\n", token
->text
, token
->arg
);
184 vty_out(vty
, "func: %p\n", element
->func
);
188 assert(MATCHER_ERROR(result
));
190 case MATCHER_NO_MATCH
:
191 vty_out(vty
, "%% Unknown command\n");
193 case MATCHER_INCOMPLETE
:
194 vty_out(vty
, "%% Incomplete command\n");
196 case MATCHER_AMBIGUOUS
:
197 vty_out(vty
, "%% Ambiguous command\n");
200 vty_out(vty
, "%% Unknown error\n");
206 cmd_free_strvec(command
);
207 XFREE(MTYPE_TMP
, cmdstr
);
213 * Testing shim to test docstrings
215 DEFUN (grammar_test_doc
,
216 grammar_test_doc_cmd
,
217 "grammar test docstring",
219 "Test function for docstring\n"
224 // create cmd_element with docstring
225 struct cmd_element
*cmd
=
226 XCALLOC(MTYPE_CMD_TOKENS
, sizeof(struct cmd_element
));
227 cmd
->string
= XSTRDUP(
229 "test docstring <example|selector follow> (1-255) end VARIABLE [OPTION|set lol] . VARARG");
230 cmd
->doc
= XSTRDUP(MTYPE_CMD_TOKENS
,
239 "optional variable\n"
246 cmd_graph_parse(nodegraph
, cmd
);
252 * Debugging command to print command graph
254 DEFUN (grammar_test_show
,
255 grammar_test_show_cmd
,
256 "grammar show [doc]",
258 "print current accumulated DFA\n"
259 "include docstrings\n")
263 struct graph_node
*stack
[CMD_ARGC_MAX
];
264 pretty_print_graph(vty
, vector_slot(nodegraph
->nodes
, 0), 0, argc
>= 3,
269 DEFUN (grammar_test_dot
,
270 grammar_test_dot_cmd
,
271 "grammar dotfile OUTNAME",
273 "print current graph for dot\n"
277 FILE *ofd
= fopen(argv
[2]->arg
, "w");
280 vty_out(vty
, "%s: %s\r\n", argv
[2]->arg
, strerror(errno
));
284 char *dot
= cmd_graph_dump_dot(nodegraph
);
286 fprintf(ofd
, "%s", dot
);
288 XFREE(MTYPE_TMP
, dot
);
293 struct cmd_permute_item
{
295 struct cmd_element
*el
;
298 static void cmd_permute_free(void *arg
)
300 struct cmd_permute_item
*i
= arg
;
301 XFREE(MTYPE_TMP
, i
->cmd
);
305 static int cmd_permute_cmp(void *a
, void *b
)
307 struct cmd_permute_item
*aa
= a
, *bb
= b
;
308 return strcmp(aa
->cmd
, bb
->cmd
);
311 static void cmd_graph_permute(struct list
*out
, struct graph_node
**stack
,
312 size_t stackpos
, char *cmd
)
314 struct graph_node
*gn
= stack
[stackpos
];
315 struct cmd_token
*tok
= gn
->data
;
316 char *appendp
= cmd
+ strlen(cmd
);
319 if (tok
->type
< SPECIAL_TKN
) {
320 sprintf(appendp
, "%s ", tok
->text
);
321 appendp
+= strlen(appendp
);
322 } else if (tok
->type
== END_TKN
) {
323 struct cmd_permute_item
*i
= XMALLOC(MTYPE_TMP
, sizeof(*i
));
324 i
->el
= ((struct graph_node
*)vector_slot(gn
->to
, 0))->data
;
325 i
->cmd
= XSTRDUP(MTYPE_TMP
, cmd
);
326 i
->cmd
[strlen(cmd
) - 1] = '\0';
327 listnode_add_sort(out
, i
);
331 if (++stackpos
== CMD_ARGC_MAX
)
334 for (size_t i
= 0; i
< vector_active(gn
->to
); i
++) {
335 struct graph_node
*gnext
= vector_slot(gn
->to
, i
);
336 for (j
= 0; j
< stackpos
; j
++)
337 if (stack
[j
] == gnext
)
342 stack
[stackpos
] = gnext
;
344 cmd_graph_permute(out
, stack
, stackpos
, cmd
);
348 static struct list
*cmd_graph_permutations(struct graph
*graph
)
350 char accumulate
[2048] = "";
351 struct graph_node
*stack
[CMD_ARGC_MAX
];
353 struct list
*rv
= list_new();
354 rv
->cmp
= cmd_permute_cmp
;
355 rv
->del
= cmd_permute_free
;
356 stack
[0] = vector_slot(graph
->nodes
, 0);
357 cmd_graph_permute(rv
, stack
, 0, accumulate
);
361 extern vector cmdvec
;
363 DEFUN (grammar_findambig
,
364 grammar_findambig_cmd
,
365 "grammar find-ambiguous [{printall|nodescan}]",
367 "Find ambiguous commands\n"
368 "Print all permutations\n"
371 struct list
*commands
;
372 struct cmd_permute_item
*prev
= NULL
, *cur
= NULL
;
374 int i
, printall
, scan
, scannode
= 0;
378 printall
= argv_find(argv
, argc
, "printall", &i
);
380 scan
= argv_find(argv
, argc
, "nodescan", &i
);
382 if (scan
&& nodegraph_free
) {
383 graph_delete_graph(nodegraph_free
);
384 nodegraph_free
= NULL
;
387 if (!scan
&& !nodegraph
) {
388 vty_out(vty
, "nodegraph uninitialized\r\n");
389 return CMD_WARNING_CONFIG_FAILED
;
394 struct cmd_node
*cnode
=
395 vector_slot(cmdvec
, scannode
++);
398 nodegraph
= cnode
->cmdgraph
;
401 vty_out(vty
, "scanning node %d (%s)\n", scannode
- 1,
405 commands
= cmd_graph_permutations(nodegraph
);
407 for (ALL_LIST_ELEMENTS_RO(commands
, ln
, cur
)) {
408 int same
= prev
&& !strcmp(prev
->cmd
, cur
->cmd
);
409 if (printall
&& !same
)
410 vty_out(vty
, "'%s' [%x]\n", cur
->cmd
,
413 vty_out(vty
, "'%s' AMBIGUOUS:\n", cur
->cmd
);
414 vty_out(vty
, " %s\n '%s'\n", prev
->el
->name
,
416 vty_out(vty
, " %s\n '%s'\n", cur
->el
->name
,
423 list_delete(&commands
);
426 } while (scan
&& scannode
< LINK_PARAMS_NODE
);
428 vty_out(vty
, "%d ambiguous commands found.\n", ambig
);
432 return ambig
== 0 ? CMD_SUCCESS
: CMD_WARNING_CONFIG_FAILED
;
435 DEFUN (grammar_init_graph
,
436 grammar_init_graph_cmd
,
439 "(re)initialize graph\n")
442 graph_delete_graph(nodegraph_free
);
443 nodegraph_free
= NULL
;
445 init_cmdgraph(vty
, &nodegraph
);
449 DEFUN (grammar_access
,
451 "grammar access (0-65535)",
453 "access node graph\n"
457 graph_delete_graph(nodegraph_free
);
458 nodegraph_free
= NULL
;
460 struct cmd_node
*cnode
;
462 cnode
= vector_slot(cmdvec
, atoi(argv
[2]->arg
));
464 vty_out(vty
, "%% no such node\n");
465 return CMD_WARNING_CONFIG_FAILED
;
468 vty_out(vty
, "node %d\n", (int)cnode
->node
);
469 nodegraph
= cnode
->cmdgraph
;
473 /* this is called in vtysh.c to set up the testing shim */
474 void grammar_sandbox_init(void)
476 // install all enable elements
477 install_element(ENABLE_NODE
, &grammar_test_cmd
);
478 install_element(ENABLE_NODE
, &grammar_test_show_cmd
);
479 install_element(ENABLE_NODE
, &grammar_test_dot_cmd
);
480 install_element(ENABLE_NODE
, &grammar_test_match_cmd
);
481 install_element(ENABLE_NODE
, &grammar_test_complete_cmd
);
482 install_element(ENABLE_NODE
, &grammar_test_doc_cmd
);
483 install_element(ENABLE_NODE
, &grammar_findambig_cmd
);
484 install_element(ENABLE_NODE
, &grammar_init_graph_cmd
);
485 install_element(ENABLE_NODE
, &grammar_access_cmd
);
489 * Pretty-prints a graph, assuming it is a tree.
491 * @param start the node to take as the root
492 * @param level indent level for recursive calls, always pass 0
494 static void pretty_print_graph(struct vty
*vty
, struct graph_node
*start
,
495 int level
, int desc
, struct graph_node
**stack
,
500 struct cmd_token
*tok
= start
->data
;
502 snprintf(tokennum
, sizeof(tokennum
), "%d?", tok
->type
);
503 vty_out(vty
, "%s", lookup_msg(tokennames
, tok
->type
, NULL
));
505 vty_out(vty
, ":\"%s\"", tok
->text
);
507 vty_out(vty
, " => %s", tok
->varname
);
509 vty_out(vty
, " ?'%s'", tok
->desc
);
512 if (stackpos
== CMD_ARGC_MAX
) {
513 vty_out(vty
, " -aborting! (depth limit)\n");
516 stack
[stackpos
++] = start
;
518 int numto
= desc
? 2 : vector_active(start
->to
);
522 for (unsigned int i
= 0; i
< vector_active(start
->to
); i
++) {
523 struct graph_node
*adj
= vector_slot(start
->to
, i
);
524 // if we're listing multiple children, indent!
526 for (int j
= 0; j
< level
+ 1; j
++)
528 // if this node is a vararg, just print *
531 else if (((struct cmd_token
*)adj
->data
)->type
533 vty_out(vty
, "--END\n");
536 for (k
= 0; k
< stackpos
; k
++)
537 if (stack
[k
] == adj
) {
538 vty_out(vty
, "<<loop@%zu \n",
545 numto
> 1 ? level
+ 1 : level
,
546 desc
, stack
, stackpos
);
553 /** stuff that should go in command.c + command.h */
554 static void init_cmdgraph(struct vty
*vty
, struct graph
**graph
)
556 // initialize graph, add start noe
557 *graph
= graph_new();
558 nodegraph_free
= *graph
;
559 struct cmd_token
*token
= cmd_token_new(START_TKN
, 0, NULL
, NULL
);
560 graph_new_node(*graph
, token
, (void (*)(void *)) & cmd_token_del
);
562 vty_out(vty
, "initialized graph\n");