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
31 #include "memory_vty.h"
34 #include "command_match.h"
36 #define GRAMMAR_STR "CLI grammar sandbox\n"
38 DEFINE_MTYPE_STATIC(LIB
, CMD_TOKENS
, "Command desc")
41 void grammar_sandbox_init(void);
42 void pretty_print_graph(struct vty
*vty
, struct graph_node
*, int, int,
43 struct graph_node
**, size_t);
44 void init_cmdgraph(struct vty
*, struct graph
**);
46 /** shim interface commands **/
47 struct graph
*nodegraph
= NULL
, *nodegraph_free
= NULL
;
49 #define check_nodegraph() \
52 vty_out(vty, "nodegraph not initialized\n"); \
59 "grammar parse LINE...",
62 "command to pass to new parser\n")
67 // make a string from tokenized command line
68 char *command
= argv_concat(argv
, argc
, idx_command
);
70 // create cmd_element for parser
71 struct cmd_element
*cmd
=
72 XCALLOC(MTYPE_CMD_TOKENS
, sizeof(struct cmd_element
));
73 cmd
->string
= command
;
75 "0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n";
78 // parse the command and install it into the command graph
79 struct graph
*graph
= graph_new();
80 struct cmd_token
*token
=
81 cmd_token_new(START_TKN
, CMD_ATTR_NORMAL
, NULL
, NULL
);
82 graph_new_node(graph
, token
, (void (*)(void *)) & cmd_token_del
);
84 cmd_graph_parse(graph
, cmd
);
85 cmd_graph_merge(nodegraph
, graph
, +1);
90 DEFUN (grammar_test_complete
,
91 grammar_test_complete_cmd
,
92 "grammar complete COMMAND...",
94 "attempt to complete input on DFA\n"
95 "command to complete\n")
100 char *cmdstr
= argv_concat(argv
, argc
, idx_command
);
104 vector command
= cmd_make_strvec(cmdstr
);
106 XFREE(MTYPE_TMP
, cmdstr
);
110 // generate completions of user input
111 struct list
*completions
;
112 enum matcher_rv result
=
113 command_complete(nodegraph
, command
, &completions
);
115 // print completions or relevant error message
116 if (!MATCHER_ERROR(result
)) {
117 vector comps
= completions_to_vec(completions
);
118 struct cmd_token
*tkn
;
120 // calculate length of longest tkn->text in completions
121 unsigned int width
= 0, i
= 0;
122 for (i
= 0; i
< vector_active(comps
); i
++) {
123 tkn
= vector_slot(comps
, i
);
124 unsigned int len
= strlen(tkn
->text
);
125 width
= len
> width
? len
: width
;
129 for (i
= 0; i
< vector_active(comps
); i
++) {
130 tkn
= vector_slot(comps
, i
);
131 vty_out(vty
, " %-*s %s\n", width
, tkn
->text
,
135 for (i
= 0; i
< vector_active(comps
); i
++)
137 (struct cmd_token
*)vector_slot(comps
, i
));
140 vty_out(vty
, "%% No match\n");
143 list_delete_and_null(&completions
);
144 cmd_free_strvec(command
);
145 XFREE(MTYPE_TMP
, cmdstr
);
150 DEFUN (grammar_test_match
,
151 grammar_test_match_cmd
,
152 "grammar match COMMAND...",
154 "attempt to match input on DFA\n"
155 "command to match\n")
160 if (argv
[2]->arg
[0] == '#')
163 char *cmdstr
= argv_concat(argv
, argc
, idx_command
);
166 vector command
= cmd_make_strvec(cmdstr
);
168 XFREE(MTYPE_TMP
, cmdstr
);
172 struct list
*argvv
= NULL
;
173 const struct cmd_element
*element
= NULL
;
174 enum matcher_rv result
=
175 command_match(nodegraph
, command
, &argvv
, &element
);
177 // print completions or relevant error message
179 vty_out(vty
, "Matched: %s\n", element
->string
);
181 struct cmd_token
*token
;
182 for (ALL_LIST_ELEMENTS_RO(argvv
, ln
, token
))
183 vty_out(vty
, "%s -- %s\n", token
->text
, token
->arg
);
185 vty_out(vty
, "func: %p\n", element
->func
);
187 list_delete_and_null(&argvv
);
189 assert(MATCHER_ERROR(result
));
191 case MATCHER_NO_MATCH
:
192 vty_out(vty
, "%% Unknown command\n");
194 case MATCHER_INCOMPLETE
:
195 vty_out(vty
, "%% Incomplete command\n");
197 case MATCHER_AMBIGUOUS
:
198 vty_out(vty
, "%% Ambiguous command\n");
201 vty_out(vty
, "%% Unknown error\n");
207 cmd_free_strvec(command
);
208 XFREE(MTYPE_TMP
, cmdstr
);
214 * Testing shim to test docstrings
216 DEFUN (grammar_test_doc
,
217 grammar_test_doc_cmd
,
218 "grammar test docstring",
220 "Test function for docstring\n"
225 // create cmd_element with docstring
226 struct cmd_element
*cmd
=
227 XCALLOC(MTYPE_CMD_TOKENS
, sizeof(struct cmd_element
));
228 cmd
->string
= XSTRDUP(
230 "test docstring <example|selector follow> (1-255) end VARIABLE [OPTION|set lol] . VARARG");
231 cmd
->doc
= XSTRDUP(MTYPE_CMD_TOKENS
,
240 "optional variable\n"
247 cmd_graph_parse(nodegraph
, cmd
);
253 * Debugging command to print command graph
255 DEFUN (grammar_test_show
,
256 grammar_test_show_cmd
,
257 "grammar show [doc]",
259 "print current accumulated DFA\n"
260 "include docstrings\n")
264 struct graph_node
*stack
[CMD_ARGC_MAX
];
265 pretty_print_graph(vty
, vector_slot(nodegraph
->nodes
, 0), 0, argc
>= 3,
270 DEFUN (grammar_test_dot
,
271 grammar_test_dot_cmd
,
272 "grammar dotfile OUTNAME",
274 "print current graph for dot\n"
278 FILE *ofd
= fopen(argv
[2]->arg
, "w");
281 vty_out(vty
, "%s: %s\r\n", argv
[2]->arg
, strerror(errno
));
285 char *dot
= cmd_graph_dump_dot(nodegraph
);
287 fprintf(ofd
, "%s", dot
);
289 XFREE(MTYPE_TMP
, dot
);
294 struct cmd_permute_item
{
296 struct cmd_element
*el
;
299 static void cmd_permute_free(void *arg
)
301 struct cmd_permute_item
*i
= arg
;
302 XFREE(MTYPE_TMP
, i
->cmd
);
306 static int cmd_permute_cmp(void *a
, void *b
)
308 struct cmd_permute_item
*aa
= a
, *bb
= b
;
309 return strcmp(aa
->cmd
, bb
->cmd
);
312 static void cmd_graph_permute(struct list
*out
, struct graph_node
**stack
,
313 size_t stackpos
, char *cmd
)
315 struct graph_node
*gn
= stack
[stackpos
];
316 struct cmd_token
*tok
= gn
->data
;
317 char *appendp
= cmd
+ strlen(cmd
);
320 if (tok
->type
< SPECIAL_TKN
) {
321 sprintf(appendp
, "%s ", tok
->text
);
322 appendp
+= strlen(appendp
);
323 } else if (tok
->type
== END_TKN
) {
324 struct cmd_permute_item
*i
= XMALLOC(MTYPE_TMP
, sizeof(*i
));
325 i
->el
= ((struct graph_node
*)vector_slot(gn
->to
, 0))->data
;
326 i
->cmd
= XSTRDUP(MTYPE_TMP
, cmd
);
327 i
->cmd
[strlen(cmd
) - 1] = '\0';
328 listnode_add_sort(out
, i
);
332 if (++stackpos
== CMD_ARGC_MAX
)
335 for (i
= 0; i
< vector_active(gn
->to
); i
++) {
336 struct graph_node
*gnext
= vector_slot(gn
->to
, i
);
337 for (j
= 0; j
< stackpos
; j
++)
338 if (stack
[j
] == gnext
)
343 stack
[stackpos
] = gnext
;
345 cmd_graph_permute(out
, stack
, stackpos
, cmd
);
349 static struct list
*cmd_graph_permutations(struct graph
*graph
)
351 char accumulate
[2048] = "";
352 struct graph_node
*stack
[CMD_ARGC_MAX
];
354 struct list
*rv
= list_new();
355 rv
->cmp
= cmd_permute_cmp
;
356 rv
->del
= cmd_permute_free
;
357 stack
[0] = vector_slot(graph
->nodes
, 0);
358 cmd_graph_permute(rv
, stack
, 0, accumulate
);
362 extern vector cmdvec
;
364 DEFUN (grammar_findambig
,
365 grammar_findambig_cmd
,
366 "grammar find-ambiguous [{printall|nodescan}]",
368 "Find ambiguous commands\n"
369 "Print all permutations\n"
372 struct list
*commands
;
373 struct cmd_permute_item
*prev
= NULL
, *cur
= NULL
;
375 int i
, printall
, scan
, scannode
= 0;
379 printall
= argv_find(argv
, argc
, "printall", &i
);
381 scan
= argv_find(argv
, argc
, "nodescan", &i
);
383 if (scan
&& nodegraph_free
) {
384 graph_delete_graph(nodegraph_free
);
385 nodegraph_free
= NULL
;
388 if (!scan
&& !nodegraph
) {
389 vty_out(vty
, "nodegraph uninitialized\r\n");
390 return CMD_WARNING_CONFIG_FAILED
;
395 struct cmd_node
*cnode
=
396 vector_slot(cmdvec
, scannode
++);
399 nodegraph
= cnode
->cmdgraph
;
402 vty_out(vty
, "scanning node %d (%s)\n", scannode
- 1,
403 node_names
[scannode
- 1]);
406 commands
= cmd_graph_permutations(nodegraph
);
408 for (ALL_LIST_ELEMENTS_RO(commands
, ln
, cur
)) {
409 int same
= prev
&& !strcmp(prev
->cmd
, cur
->cmd
);
410 if (printall
&& !same
)
411 vty_out(vty
, "'%s' [%x]\n", cur
->cmd
,
414 vty_out(vty
, "'%s' AMBIGUOUS:\n", cur
->cmd
);
415 vty_out(vty
, " %s\n '%s'\n", prev
->el
->name
,
417 vty_out(vty
, " %s\n '%s'\n", cur
->el
->name
,
424 list_delete_and_null(&commands
);
427 } while (scan
&& scannode
< LINK_PARAMS_NODE
);
429 vty_out(vty
, "%d ambiguous commands found.\n", ambig
);
433 return ambig
== 0 ? CMD_SUCCESS
: CMD_WARNING_CONFIG_FAILED
;
436 DEFUN (grammar_init_graph
,
437 grammar_init_graph_cmd
,
440 "(re)initialize graph\n")
443 graph_delete_graph(nodegraph_free
);
444 nodegraph_free
= NULL
;
446 init_cmdgraph(vty
, &nodegraph
);
450 DEFUN (grammar_access
,
452 "grammar access (0-65535)",
454 "access node graph\n"
458 graph_delete_graph(nodegraph_free
);
459 nodegraph_free
= NULL
;
461 struct cmd_node
*cnode
;
463 cnode
= vector_slot(cmdvec
, atoi(argv
[2]->arg
));
465 vty_out(vty
, "%% no such node\n");
466 return CMD_WARNING_CONFIG_FAILED
;
469 vty_out(vty
, "node %d\n", (int)cnode
->node
);
470 nodegraph
= cnode
->cmdgraph
;
474 /* this is called in vtysh.c to set up the testing shim */
475 void grammar_sandbox_init(void)
477 // install all enable elements
478 install_element(ENABLE_NODE
, &grammar_test_cmd
);
479 install_element(ENABLE_NODE
, &grammar_test_show_cmd
);
480 install_element(ENABLE_NODE
, &grammar_test_dot_cmd
);
481 install_element(ENABLE_NODE
, &grammar_test_match_cmd
);
482 install_element(ENABLE_NODE
, &grammar_test_complete_cmd
);
483 install_element(ENABLE_NODE
, &grammar_test_doc_cmd
);
484 install_element(ENABLE_NODE
, &grammar_findambig_cmd
);
485 install_element(ENABLE_NODE
, &grammar_init_graph_cmd
);
486 install_element(ENABLE_NODE
, &grammar_access_cmd
);
490 * Pretty-prints a graph, assuming it is a tree.
492 * @param start the node to take as the root
493 * @param level indent level for recursive calls, always pass 0
495 void pretty_print_graph(struct vty
*vty
, struct graph_node
*start
, int level
,
496 int desc
, struct graph_node
**stack
, size_t stackpos
)
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 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");