2 * CLI backend interface.
5 * Copyright (C) 2016 Cumulus Networks, Inc.
6 * Copyright (C) 1997, 98, 99 Kunihiro Ishiguro
7 * Copyright (C) 2013 by Open Source Routing.
8 * Copyright (C) 2013 by Internet Systems Consortium, Inc. ("ISC")
10 * This file is part of GNU Zebra.
12 * GNU Zebra is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU General Public License as published by the
14 * Free Software Foundation; either version 2, or (at your option) any
17 * GNU Zebra is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
22 * You should have received a copy of the GNU General Public License along
23 * with this program; see the file COPYING; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
28 #include <lib/version.h>
39 #include "workqueue.h"
41 #include "command_match.h"
42 #include "command_graph.h"
48 #include "lib_errors.h"
49 #include "northbound_cli.h"
52 #include "frrscript.h"
54 DEFINE_MTYPE_STATIC(LIB
, HOST
, "Host config");
55 DEFINE_MTYPE(LIB
, COMPLETION
, "Completion item");
62 /* clang-format off */
63 const struct message tokennames
[] = {
68 item(IPV4_PREFIX_TKN
),
70 item(IPV6_PREFIX_TKN
),
82 /* Command vector which includes some level of command lists. Normally
83 each daemon maintains each own cmdvec. */
86 /* Host information structure. */
89 /* for vtysh, put together CLI trees only when switching into node */
90 static bool defer_cli_tree
;
93 * Returns host.name if any, otherwise
94 * it returns the system hostname.
96 const char *cmd_hostname_get(void)
102 * Returns unix domainname
104 const char *cmd_domainname_get(void)
106 return host
.domainname
;
109 const char *cmd_system_get(void)
114 const char *cmd_release_get(void)
119 const char *cmd_version_get(void)
124 bool cmd_allow_reserved_ranges_get(void)
126 return host
.allow_reserved_ranges
;
129 static int root_on_exit(struct vty
*vty
);
131 /* Standard command node structures. */
132 static struct cmd_node auth_node
= {
135 .prompt
= "Password: ",
138 static struct cmd_node view_node
= {
142 .node_exit
= root_on_exit
,
145 static struct cmd_node auth_enable_node
= {
146 .name
= "auth enable",
147 .node
= AUTH_ENABLE_NODE
,
148 .prompt
= "Password: ",
151 static struct cmd_node enable_node
= {
155 .node_exit
= root_on_exit
,
158 static int config_write_host(struct vty
*vty
);
159 static struct cmd_node config_node
= {
162 .parent_node
= ENABLE_NODE
,
163 .prompt
= "%s(config)# ",
164 .config_write
= config_write_host
,
165 .node_exit
= vty_config_node_exit
,
168 /* This is called from main when a daemon is invoked with -v or --version. */
169 void print_version(const char *progname
)
171 printf("%s version %s\n", progname
, FRR_VERSION
);
172 printf("%s\n", FRR_COPYRIGHT
);
173 #ifdef ENABLE_VERSION_BUILD_CONFIG
174 printf("configured with:\n\t%s\n", FRR_CONFIG_ARGS
);
178 char *argv_concat(struct cmd_token
**argv
, int argc
, int shift
)
180 int cnt
= MAX(argc
- shift
, 0);
181 const char *argstr
[cnt
+ 1];
186 for (int i
= 0; i
< cnt
; i
++)
187 argstr
[i
] = argv
[i
+ shift
]->arg
;
189 return frrstr_join(argstr
, cnt
, " ");
192 vector
cmd_make_strvec(const char *string
)
197 const char *copy
= string
;
199 /* skip leading whitespace */
200 while (isspace((unsigned char)*copy
) && *copy
!= '\0')
203 /* if the entire string was whitespace or a comment, return */
204 if (*copy
== '\0' || *copy
== '!' || *copy
== '#')
207 vector result
= frrstr_split_vec(copy
, "\n\r\t ");
209 for (unsigned int i
= 0; i
< vector_active(result
); i
++) {
210 if (strlen(vector_slot(result
, i
)) == 0) {
211 XFREE(MTYPE_TMP
, vector_slot(result
, i
));
212 vector_unset(result
, i
);
216 vector_compact(result
);
221 void cmd_free_strvec(vector v
)
223 frrstr_strvec_free(v
);
227 * Convenience function for accessing argv data.
231 * @param text definition snippet of the desired token
232 * @param index the starting index, and where to store the
233 * index of the found token if it exists
234 * @return 1 if found, 0 otherwise
236 int argv_find(struct cmd_token
**argv
, int argc
, const char *text
, int *index
)
239 for (int i
= *index
; i
< argc
&& found
== 0; i
++)
240 if ((found
= strmatch(text
, argv
[i
]->text
)))
245 static unsigned int cmd_hash_key(const void *p
)
247 int size
= sizeof(p
);
249 return jhash(p
, size
, 0);
252 static bool cmd_hash_cmp(const void *a
, const void *b
)
257 /* Install top node of command vector. */
258 void install_node(struct cmd_node
*node
)
260 #define CMD_HASH_STR_SIZE 256
261 char hash_name
[CMD_HASH_STR_SIZE
];
263 vector_set_index(cmdvec
, node
->node
, node
);
264 node
->cmdgraph
= graph_new();
265 node
->cmd_vector
= vector_init(VECTOR_MIN_SIZE
);
267 struct cmd_token
*token
=
268 cmd_token_new(START_TKN
, CMD_ATTR_NORMAL
, NULL
, NULL
);
269 graph_new_node(node
->cmdgraph
, token
,
270 (void (*)(void *)) & cmd_token_del
);
272 snprintf(hash_name
, sizeof(hash_name
), "Command Hash: %s", node
->name
);
274 hash_create_size(16, cmd_hash_key
, cmd_hash_cmp
, hash_name
);
277 /* Return prompt character of specified node. */
278 const char *cmd_prompt(enum node_type node
)
280 struct cmd_node
*cnode
;
282 cnode
= vector_slot(cmdvec
, node
);
283 return cnode
->prompt
;
286 void cmd_defer_tree(bool val
)
288 defer_cli_tree
= val
;
291 /* Install a command into a node. */
292 void _install_element(enum node_type ntype
, const struct cmd_element
*cmd
)
294 struct cmd_node
*cnode
;
296 /* cmd_init hasn't been called */
298 fprintf(stderr
, "%s called before cmd_init, breakage likely\n",
303 cnode
= vector_lookup(cmdvec
, ntype
);
308 "\tnode %d does not exist.\n"
309 "\tplease call install_node() before install_element()\n",
310 cmd
->name
, cmd
->string
, ntype
);
314 if (hash_lookup(cnode
->cmd_hash
, (void *)cmd
) != NULL
) {
317 "\tnode %d (%s) already has this command installed.\n"
318 "\tduplicate install_element call?\n",
319 cmd
->name
, cmd
->string
, ntype
, cnode
->name
);
323 (void)hash_get(cnode
->cmd_hash
, (void *)cmd
, hash_alloc_intern
);
325 if (cnode
->graph_built
|| !defer_cli_tree
) {
326 struct graph
*graph
= graph_new();
327 struct cmd_token
*token
=
328 cmd_token_new(START_TKN
, CMD_ATTR_NORMAL
, NULL
, NULL
);
329 graph_new_node(graph
, token
,
330 (void (*)(void *)) & cmd_token_del
);
332 cmd_graph_parse(graph
, cmd
);
333 cmd_graph_names(graph
);
334 cmd_graph_merge(cnode
->cmdgraph
, graph
, +1);
335 graph_delete_graph(graph
);
337 cnode
->graph_built
= true;
340 vector_set(cnode
->cmd_vector
, (void *)cmd
);
342 if (ntype
== VIEW_NODE
)
343 _install_element(ENABLE_NODE
, cmd
);
346 static void cmd_finalize_iter(struct hash_bucket
*hb
, void *arg
)
348 struct cmd_node
*cnode
= arg
;
349 const struct cmd_element
*cmd
= hb
->data
;
350 struct graph
*graph
= graph_new();
351 struct cmd_token
*token
=
352 cmd_token_new(START_TKN
, CMD_ATTR_NORMAL
, NULL
, NULL
);
354 graph_new_node(graph
, token
, (void (*)(void *)) & cmd_token_del
);
356 cmd_graph_parse(graph
, cmd
);
357 cmd_graph_names(graph
);
358 cmd_graph_merge(cnode
->cmdgraph
, graph
, +1);
359 graph_delete_graph(graph
);
362 void cmd_finalize_node(struct cmd_node
*cnode
)
364 if (cnode
->graph_built
)
367 hash_iterate(cnode
->cmd_hash
, cmd_finalize_iter
, cnode
);
368 cnode
->graph_built
= true;
371 void uninstall_element(enum node_type ntype
, const struct cmd_element
*cmd
)
373 struct cmd_node
*cnode
;
375 /* cmd_init hasn't been called */
377 fprintf(stderr
, "%s called before cmd_init, breakage likely\n",
382 cnode
= vector_lookup(cmdvec
, ntype
);
387 "\tnode %d does not exist.\n"
388 "\tplease call install_node() before uninstall_element()\n",
389 cmd
->name
, cmd
->string
, ntype
);
393 if (hash_release(cnode
->cmd_hash
, (void *)cmd
) == NULL
) {
396 "\tnode %d (%s) does not have this command installed.\n"
397 "\tduplicate uninstall_element call?\n",
398 cmd
->name
, cmd
->string
, ntype
, cnode
->name
);
402 vector_unset_value(cnode
->cmd_vector
, (void *)cmd
);
404 if (cnode
->graph_built
) {
405 struct graph
*graph
= graph_new();
406 struct cmd_token
*token
=
407 cmd_token_new(START_TKN
, CMD_ATTR_NORMAL
, NULL
, NULL
);
408 graph_new_node(graph
, token
,
409 (void (*)(void *)) & cmd_token_del
);
411 cmd_graph_parse(graph
, cmd
);
412 cmd_graph_names(graph
);
413 cmd_graph_merge(cnode
->cmdgraph
, graph
, -1);
414 graph_delete_graph(graph
);
417 if (ntype
== VIEW_NODE
)
418 uninstall_element(ENABLE_NODE
, cmd
);
422 static const unsigned char itoa64
[] =
423 "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
425 static void to64(char *s
, long v
, int n
)
428 *s
++ = itoa64
[v
& 0x3f];
433 static char *zencrypt(const char *passwd
)
438 gettimeofday(&tv
, 0);
440 to64(&salt
[0], frr_weak_random(), 3);
441 to64(&salt
[3], tv
.tv_usec
, 3);
444 return crypt(passwd
, salt
);
447 static bool full_cli
;
449 /* This function write configuration of this host. */
450 static int config_write_host(struct vty
*vty
)
454 name
= cmd_hostname_get();
455 if (name
&& name
[0] != '\0')
456 vty_out(vty
, "hostname %s\n", name
);
458 name
= cmd_domainname_get();
459 if (name
&& name
[0] != '\0')
460 vty_out(vty
, "domainname %s\n", name
);
462 if (cmd_allow_reserved_ranges_get())
463 vty_out(vty
, "allow-reserved-ranges\n");
465 /* The following are all configuration commands that are not sent to
466 * watchfrr. For instance watchfrr is hardcoded to log to syslog so
467 * we would always display 'log syslog informational' in the config
468 * which would cause other daemons to then switch to syslog when they
473 if (host
.password_encrypt
)
474 vty_out(vty
, "password 8 %s\n",
475 host
.password_encrypt
);
476 if (host
.enable_encrypt
)
477 vty_out(vty
, "enable password 8 %s\n",
478 host
.enable_encrypt
);
481 vty_out(vty
, "password %s\n", host
.password
);
483 vty_out(vty
, "enable password %s\n",
486 log_config_write(vty
);
488 /* print disable always, but enable only if default is flipped
489 * => prep for future removal of compile-time knob
491 if (!cputime_enabled
)
492 vty_out(vty
, "no service cputime-stats\n");
493 #ifdef EXCLUDE_CPU_TIME
495 vty_out(vty
, "service cputime-stats\n");
498 if (!cputime_threshold
)
499 vty_out(vty
, "no service cputime-warning\n");
500 #if defined(CONSUMED_TIME_CHECK) && CONSUMED_TIME_CHECK != 5000000
501 else /* again, always print non-default */
503 else if (cputime_threshold
!= 5000000)
505 vty_out(vty
, "service cputime-warning %lu\n",
508 if (!walltime_threshold
)
509 vty_out(vty
, "no service walltime-warning\n");
510 #if defined(CONSUMED_TIME_CHECK) && CONSUMED_TIME_CHECK != 5000000
511 else /* again, always print non-default */
513 else if (walltime_threshold
!= 5000000)
515 vty_out(vty
, "service walltime-warning %lu\n",
519 vty_out(vty
, "service advanced-vty\n");
522 vty_out(vty
, "service password-encryption\n");
525 vty_out(vty
, "service terminal-length %d\n",
529 vty_out(vty
, "banner motd file %s\n", host
.motdfile
);
531 && strncmp(host
.motd
, FRR_DEFAULT_MOTD
,
533 vty_out(vty
, "banner motd line %s\n", host
.motd
);
535 vty_out(vty
, "no banner motd\n");
538 if (debug_memstats_at_exit
)
539 vty_out(vty
, "!\ndebug memstats-at-exit\n");
544 /* Utility function for getting command graph. */
545 static struct graph
*cmd_node_graph(vector v
, enum node_type ntype
)
547 struct cmd_node
*cnode
= vector_slot(v
, ntype
);
549 cmd_finalize_node(cnode
);
550 return cnode
->cmdgraph
;
553 static int cmd_try_do_shortcut(enum node_type node
, char *first_word
)
555 if (first_word
!= NULL
&& node
!= AUTH_NODE
&& node
!= VIEW_NODE
556 && node
!= AUTH_ENABLE_NODE
&& 0 == strcmp("do", first_word
))
562 * Compare function for cmd_token.
563 * Used with qsort to sort command completions.
565 static int compare_completions(const void *fst
, const void *snd
)
567 const struct cmd_token
*first
= *(const struct cmd_token
* const *)fst
,
568 *secnd
= *(const struct cmd_token
* const *)snd
;
569 return strcmp(first
->text
, secnd
->text
);
573 * Takes a list of completions returned by command_complete,
574 * dedeuplicates them based on both text and description,
575 * sorts them, and returns them as a vector.
577 * @param completions linked list of cmd_token
578 * @return deduplicated and sorted vector with
580 vector
completions_to_vec(struct list
*completions
)
582 vector comps
= vector_init(VECTOR_MIN_SIZE
);
585 struct cmd_token
*token
, *cr
= NULL
;
586 unsigned int i
, exists
;
587 for (ALL_LIST_ELEMENTS_RO(completions
, ln
, token
)) {
588 if (token
->type
== END_TKN
&& (cr
= token
))
591 // linear search for token in completions vector
593 for (i
= 0; i
< vector_active(comps
) && !exists
; i
++) {
594 struct cmd_token
*curr
= vector_slot(comps
, i
);
596 exists
= !strcmp(curr
->text
, token
->text
)
597 && !strcmp(curr
->desc
, token
->desc
);
599 exists
= !strcmp(curr
->text
, token
->text
);
600 #endif /* VTYSH_DEBUG */
604 vector_set(comps
, token
);
608 qsort(comps
->index
, vector_active(comps
), sizeof(void *),
609 &compare_completions
);
611 // make <cr> the first element, if it is present
613 vector_set_index(comps
, vector_active(comps
), NULL
);
614 memmove(comps
->index
+ 1, comps
->index
,
615 (comps
->alloced
- 1) * sizeof(void *));
616 vector_set_index(comps
, 0, cr
);
622 * Generates a vector of cmd_token representing possible completions
623 * on the current input.
625 * @param vline the vectorized input line
626 * @param vty the vty with the node to match on
627 * @param status pointer to matcher status code
628 * @return vector of struct cmd_token * with possible completions
630 static vector
cmd_complete_command_real(vector vline
, struct vty
*vty
,
633 struct list
*completions
;
634 struct graph
*cmdgraph
= cmd_node_graph(cmdvec
, vty
->node
);
636 enum matcher_rv rv
= command_complete(cmdgraph
, vline
, &completions
);
638 if (MATCHER_ERROR(rv
)) {
639 *status
= CMD_ERR_NO_MATCH
;
643 vector comps
= completions_to_vec(completions
);
644 list_delete(&completions
);
646 // set status code appropriately
647 switch (vector_active(comps
)) {
649 *status
= CMD_ERR_NO_MATCH
;
652 *status
= CMD_COMPLETE_FULL_MATCH
;
655 *status
= CMD_COMPLETE_LIST_MATCH
;
661 vector
cmd_describe_command(vector vline
, struct vty
*vty
, int *status
)
665 if (cmd_try_do_shortcut(vty
->node
, vector_slot(vline
, 0))) {
666 enum node_type onode
;
667 int orig_xpath_index
;
668 vector shifted_vline
;
672 orig_xpath_index
= vty
->xpath_index
;
673 vty
->node
= ENABLE_NODE
;
674 vty
->xpath_index
= 0;
675 /* We can try it on enable node, cos' the vty is authenticated
678 shifted_vline
= vector_init(vector_count(vline
));
680 for (index
= 1; index
< vector_active(vline
); index
++) {
681 vector_set_index(shifted_vline
, index
- 1,
682 vector_lookup(vline
, index
));
685 ret
= cmd_complete_command_real(shifted_vline
, vty
, status
);
687 vector_free(shifted_vline
);
689 vty
->xpath_index
= orig_xpath_index
;
693 return cmd_complete_command_real(vline
, vty
, status
);
696 static struct list
*varhandlers
= NULL
;
698 void cmd_variable_complete(struct cmd_token
*token
, const char *arg
,
702 const struct cmd_variable_handler
*cvh
;
706 tmpcomps
= arg
? vector_init(VECTOR_MIN_SIZE
) : comps
;
708 for (ALL_LIST_ELEMENTS_RO(varhandlers
, ln
, cvh
)) {
709 if (cvh
->tokenname
&& strcmp(cvh
->tokenname
, token
->text
))
711 if (cvh
->varname
&& (!token
->varname
712 || strcmp(cvh
->varname
, token
->varname
)))
714 cvh
->completions(tmpcomps
, token
);
722 for (i
= vector_active(tmpcomps
); i
; i
--) {
723 char *item
= vector_slot(tmpcomps
, i
- 1);
724 if (strlen(item
) >= argsz
&& !strncmp(item
, arg
, argsz
))
725 vector_set(comps
, item
);
727 XFREE(MTYPE_COMPLETION
, item
);
729 vector_free(tmpcomps
);
732 #define AUTOCOMP_INDENT 5
734 char *cmd_variable_comp2str(vector comps
, unsigned short cols
)
737 char *buf
= XCALLOC(MTYPE_TMP
, bsz
);
738 int lc
= AUTOCOMP_INDENT
;
739 size_t cs
= AUTOCOMP_INDENT
;
741 snprintf(buf
, bsz
, "%*s", AUTOCOMP_INDENT
, "");
742 for (size_t j
= 0; j
< vector_active(comps
); j
++) {
743 char *item
= vector_slot(comps
, j
);
744 itemlen
= strlen(item
);
746 if (cs
+ itemlen
+ AUTOCOMP_INDENT
+ 3 >= bsz
)
747 buf
= XREALLOC(MTYPE_TMP
, buf
, (bsz
*= 2));
749 if (lc
+ itemlen
+ 1 >= cols
) {
750 cs
+= snprintf(&buf
[cs
], bsz
- cs
, "\n%*s",
751 AUTOCOMP_INDENT
, "");
752 lc
= AUTOCOMP_INDENT
;
755 size_t written
= snprintf(&buf
[cs
], bsz
- cs
, "%s ", item
);
758 XFREE(MTYPE_COMPLETION
, item
);
759 vector_set_index(comps
, j
, NULL
);
764 void cmd_variable_handler_register(const struct cmd_variable_handler
*cvh
)
769 for (; cvh
->completions
; cvh
++)
770 listnode_add(varhandlers
, (void *)cvh
);
773 DEFUN_HIDDEN (autocomplete
,
775 "autocomplete TYPE TEXT VARNAME",
776 "Autocompletion handler (internal, for vtysh)\n"
779 "cmd_token->varname\n")
781 struct cmd_token tok
;
782 vector comps
= vector_init(32);
785 memset(&tok
, 0, sizeof(tok
));
786 tok
.type
= atoi(argv
[1]->arg
);
787 tok
.text
= argv
[2]->arg
;
788 tok
.varname
= argv
[3]->arg
;
789 if (!strcmp(tok
.varname
, "-"))
792 cmd_variable_complete(&tok
, NULL
, comps
);
794 for (i
= 0; i
< vector_active(comps
); i
++) {
795 char *text
= vector_slot(comps
, i
);
796 vty_out(vty
, "%s\n", text
);
797 XFREE(MTYPE_COMPLETION
, text
);
805 * Generate possible tab-completions for the given input. This function only
806 * returns results that would result in a valid command if used as Readline
807 * completions (as is the case in vtysh). For instance, if the passed vline ends
808 * with '4.3.2', the strings 'A.B.C.D' and 'A.B.C.D/M' will _not_ be returned.
810 * @param vline vectorized input line
812 * @param status location to store matcher status code in
813 * @return set of valid strings for use with Readline as tab-completions.
816 char **cmd_complete_command(vector vline
, struct vty
*vty
, int *status
)
819 int original_node
= vty
->node
;
820 vector input_line
= vector_init(vector_count(vline
));
822 // if the first token is 'do' we'll want to execute the command in the
824 int do_shortcut
= cmd_try_do_shortcut(vty
->node
, vector_slot(vline
, 0));
825 vty
->node
= do_shortcut
? ENABLE_NODE
: original_node
;
827 // construct the input line we'll be matching on
828 unsigned int offset
= (do_shortcut
) ? 1 : 0;
829 for (unsigned index
= 0; index
+ offset
< vector_active(vline
); index
++)
830 vector_set_index(input_line
, index
,
831 vector_lookup(vline
, index
+ offset
));
833 // get token completions -- this is a copying operation
834 vector comps
= NULL
, initial_comps
;
835 initial_comps
= cmd_complete_command_real(input_line
, vty
, status
);
837 if (!MATCHER_ERROR(*status
)) {
838 assert(initial_comps
);
839 // filter out everything that is not suitable for a
841 comps
= vector_init(VECTOR_MIN_SIZE
);
842 for (unsigned int i
= 0; i
< vector_active(initial_comps
);
844 struct cmd_token
*token
= vector_slot(initial_comps
, i
);
845 if (token
->type
== WORD_TKN
)
846 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
,
848 else if (IS_VARYING_TOKEN(token
->type
)) {
849 const char *ref
= vector_lookup(
850 vline
, vector_active(vline
) - 1);
851 cmd_variable_complete(token
, ref
, comps
);
854 vector_free(initial_comps
);
856 // since we filtered results, we need to re-set status code
857 switch (vector_active(comps
)) {
859 *status
= CMD_ERR_NO_MATCH
;
862 *status
= CMD_COMPLETE_FULL_MATCH
;
865 *status
= CMD_COMPLETE_LIST_MATCH
;
868 // copy completions text into an array of char*
869 ret
= XMALLOC(MTYPE_TMP
,
870 (vector_active(comps
) + 1) * sizeof(char *));
872 for (i
= 0; i
< vector_active(comps
); i
++) {
873 ret
[i
] = vector_slot(comps
, i
);
875 // set the last element to NULL, because this array is used in
876 // a Readline completion_generator function which expects NULL
877 // as a sentinel value
881 } else if (initial_comps
)
882 vector_free(initial_comps
);
884 // comps should always be null here
887 // free the adjusted input line
888 vector_free(input_line
);
890 // reset vty->node to its original value
891 vty
->node
= original_node
;
896 /* return parent node */
897 /* MUST eventually converge on CONFIG_NODE */
898 enum node_type
node_parent(enum node_type node
)
900 struct cmd_node
*cnode
;
902 assert(node
> CONFIG_NODE
);
904 cnode
= vector_lookup(cmdvec
, node
);
906 return cnode
->parent_node
;
909 /* Execute command by argument vline vector. */
910 static int cmd_execute_command_real(vector vline
, enum cmd_filter_type filter
,
912 const struct cmd_element
**cmd
,
913 unsigned int up_level
)
915 struct list
*argv_list
;
916 enum matcher_rv status
;
917 const struct cmd_element
*matched_element
= NULL
;
919 int xpath_index
= vty
->xpath_index
;
920 int node
= vty
->node
;
922 /* only happens for legacy split config file load; need to check for
923 * a match before calling node_exit handlers below
925 for (i
= 0; i
< up_level
; i
++) {
926 struct cmd_node
*cnode
;
928 if (node
<= CONFIG_NODE
)
929 return CMD_NO_LEVEL_UP
;
931 cnode
= vector_slot(cmdvec
, node
);
932 node
= node_parent(node
);
934 if (xpath_index
> 0 && !cnode
->no_xpath
)
938 struct graph
*cmdgraph
= cmd_node_graph(cmdvec
, node
);
939 status
= command_match(cmdgraph
, vline
, &argv_list
, &matched_element
);
942 *cmd
= matched_element
;
944 // if matcher error, return corresponding CMD_ERR
945 if (MATCHER_ERROR(status
)) {
947 list_delete(&argv_list
);
949 case MATCHER_INCOMPLETE
:
950 return CMD_ERR_INCOMPLETE
;
951 case MATCHER_AMBIGUOUS
:
952 return CMD_ERR_AMBIGUOUS
;
954 return CMD_ERR_NO_MATCH
;
958 for (i
= 0; i
< up_level
; i
++)
961 // build argv array from argv list
962 struct cmd_token
**argv
= XMALLOC(
963 MTYPE_TMP
, argv_list
->count
* sizeof(struct cmd_token
*));
965 struct cmd_token
*token
;
968 for (ALL_LIST_ELEMENTS_RO(argv_list
, ln
, token
))
971 int argc
= argv_list
->count
;
974 if (matched_element
->daemon
)
975 ret
= CMD_SUCCESS_DAEMON
;
978 /* Clear array of enqueued configuration changes. */
979 vty
->num_cfg_changes
= 0;
980 memset(&vty
->cfg_changes
, 0, sizeof(vty
->cfg_changes
));
982 /* Regenerate candidate configuration if necessary. */
983 if (frr_get_cli_mode() == FRR_CLI_CLASSIC
984 && running_config
->version
985 > vty
->candidate_config
->version
)
986 nb_config_replace(vty
->candidate_config
,
987 running_config
, true);
990 * Perform pending commit (if any) before executing
993 if (matched_element
->attr
!= CMD_ATTR_YANG
)
994 (void)nb_cli_pending_commit_check(vty
);
997 ret
= matched_element
->func(matched_element
, vty
, argc
, argv
);
1000 // delete list and cmd_token's in it
1001 list_delete(&argv_list
);
1002 XFREE(MTYPE_TMP
, argv
);
1008 * Execute a given command, handling things like "do ..." and checking
1009 * whether the given command might apply at a parent node if doesn't
1010 * apply for the current node.
1012 * @param vline Command line input, vector of char* where each element is
1014 * @param vty The vty context in which the command should be executed.
1015 * @param cmd Pointer where the struct cmd_element of the matched command
1016 * will be stored, if any. May be set to NULL if this info is
1018 * @param vtysh If set != 0, don't lookup the command at parent nodes.
1019 * @return The status of the command that has been executed or an error code
1020 * as to why no command could be executed.
1022 int cmd_execute_command(vector vline
, struct vty
*vty
,
1023 const struct cmd_element
**cmd
, int vtysh
)
1025 int ret
, saved_ret
= 0;
1026 enum node_type onode
, try_node
;
1027 int orig_xpath_index
;
1029 onode
= try_node
= vty
->node
;
1030 orig_xpath_index
= vty
->xpath_index
;
1032 if (cmd_try_do_shortcut(vty
->node
, vector_slot(vline
, 0))) {
1033 vector shifted_vline
;
1036 vty
->node
= ENABLE_NODE
;
1037 vty
->xpath_index
= 0;
1038 /* We can try it on enable node, cos' the vty is authenticated
1041 shifted_vline
= vector_init(vector_count(vline
));
1043 for (index
= 1; index
< vector_active(vline
); index
++)
1044 vector_set_index(shifted_vline
, index
- 1,
1045 vector_lookup(vline
, index
));
1047 ret
= cmd_execute_command_real(shifted_vline
, FILTER_RELAXED
,
1050 vector_free(shifted_vline
);
1052 vty
->xpath_index
= orig_xpath_index
;
1057 cmd_execute_command_real(vline
, FILTER_RELAXED
, vty
, cmd
, 0);
1062 if (ret
!= CMD_SUCCESS
&& ret
!= CMD_WARNING
1063 && ret
!= CMD_ERR_AMBIGUOUS
&& ret
!= CMD_ERR_INCOMPLETE
1064 && ret
!= CMD_NOT_MY_INSTANCE
&& ret
!= CMD_WARNING_CONFIG_FAILED
) {
1065 /* This assumes all nodes above CONFIG_NODE are childs of
1067 while (vty
->node
> CONFIG_NODE
) {
1068 struct cmd_node
*cnode
= vector_slot(cmdvec
, try_node
);
1070 try_node
= node_parent(try_node
);
1071 vty
->node
= try_node
;
1072 if (vty
->xpath_index
> 0 && !cnode
->no_xpath
)
1075 ret
= cmd_execute_command_real(vline
, FILTER_RELAXED
,
1077 if (ret
== CMD_SUCCESS
|| ret
== CMD_WARNING
1078 || ret
== CMD_ERR_AMBIGUOUS
|| ret
== CMD_ERR_INCOMPLETE
1079 || ret
== CMD_NOT_MY_INSTANCE
1080 || ret
== CMD_WARNING_CONFIG_FAILED
)
1083 /* no command succeeded, reset the vty to the original node */
1085 vty
->xpath_index
= orig_xpath_index
;
1088 /* return command status for original node */
1093 * Execute a given command, matching it strictly against the current node.
1094 * This mode is used when reading config files.
1096 * @param vline Command line input, vector of char* where each element is
1098 * @param vty The vty context in which the command should be executed.
1099 * @param cmd Pointer where the struct cmd_element* of the matched command
1100 * will be stored, if any. May be set to NULL if this info is
1102 * @return The status of the command that has been executed or an error code
1103 * as to why no command could be executed.
1105 int cmd_execute_command_strict(vector vline
, struct vty
*vty
,
1106 const struct cmd_element
**cmd
)
1108 return cmd_execute_command_real(vline
, FILTER_STRICT
, vty
, cmd
, 0);
1112 * Hook for preprocessing command string before executing.
1114 * All subscribers are called with the raw command string that is to be
1115 * executed. If any changes are to be made, a new string should be allocated
1116 * with MTYPE_TMP and *cmd_out updated to point to this new string. The caller
1117 * is then responsible for freeing this string.
1119 * All processing functions must be mutually exclusive in their action, i.e. if
1120 * one subscriber decides to modify the command, all others must not modify it
1121 * when called. Feeding the output of one processing command into a subsequent
1122 * one is not supported.
1124 * This hook is intentionally internal to the command processing system.
1127 * The raw command string.
1130 * The result of any processing.
1132 DECLARE_HOOK(cmd_execute
,
1133 (struct vty
*vty
, const char *cmd_in
, char **cmd_out
),
1134 (vty
, cmd_in
, cmd_out
));
1135 DEFINE_HOOK(cmd_execute
, (struct vty
*vty
, const char *cmd_in
, char **cmd_out
),
1136 (vty
, cmd_in
, cmd_out
));
1138 /* Hook executed after a CLI command. */
1139 DECLARE_KOOH(cmd_execute_done
, (struct vty
*vty
, const char *cmd_exec
),
1141 DEFINE_KOOH(cmd_execute_done
, (struct vty
*vty
, const char *cmd_exec
),
1145 * cmd_execute hook subscriber to handle `|` actions.
1147 static int handle_pipe_action(struct vty
*vty
, const char *cmd_in
,
1151 char *orig
, *working
, *token
, *u
;
1152 char *pipe
= strstr(cmd_in
, "| ");
1158 /* duplicate string for processing purposes, not including pipe */
1159 orig
= working
= XSTRDUP(MTYPE_TMP
, pipe
+ 2);
1161 /* retrieve action */
1162 token
= strsep(&working
, " ");
1165 /* match result to known actions */
1166 if (strmatch(token
, "include")) {
1167 /* the remaining text should be a regexp */
1168 char *regexp
= working
;
1171 vty_out(vty
, "%% Need a regexp to filter with\n");
1176 bool succ
= vty_set_include(vty
, regexp
);
1179 vty_out(vty
, "%% Bad regexp '%s'\n", regexp
);
1183 *cmd_out
= XSTRDUP(MTYPE_TMP
, cmd_in
);
1187 vty_out(vty
, "%% Unknown action '%s'\n", token
);
1193 XFREE(MTYPE_TMP
, orig
);
1197 static int handle_pipe_action_done(struct vty
*vty
, const char *cmd_exec
)
1200 vty_set_include(vty
, NULL
);
1205 int cmd_execute(struct vty
*vty
, const char *cmd
,
1206 const struct cmd_element
**matched
, int vtysh
)
1209 char *cmd_out
= NULL
;
1210 const char *cmd_exec
= NULL
;
1213 ret
= hook_call(cmd_execute
, vty
, cmd
, &cmd_out
);
1219 cmd_exec
= cmd_out
? (const char *)cmd_out
: cmd
;
1221 vline
= cmd_make_strvec(cmd_exec
);
1224 ret
= cmd_execute_command(vline
, vty
, matched
, vtysh
);
1225 cmd_free_strvec(vline
);
1231 hook_call(cmd_execute_done
, vty
, cmd_exec
);
1233 XFREE(MTYPE_TMP
, cmd_out
);
1240 * Parse one line of config, walking up the parse tree attempting to find a
1243 * @param vty The vty context in which the command should be executed.
1244 * @param cmd Pointer where the struct cmd_element* of the match command
1245 * will be stored, if any. May be set to NULL if this info is
1247 * @param use_daemon Boolean to control whether or not we match on
1248 * CMD_SUCCESS_DAEMON
1250 * @return The status of the command that has been executed or an error code
1251 * as to why no command could be executed.
1253 int command_config_read_one_line(struct vty
*vty
,
1254 const struct cmd_element
**cmd
,
1255 uint32_t line_num
, int use_daemon
)
1259 unsigned up_level
= 0;
1261 vline
= cmd_make_strvec(vty
->buf
);
1263 /* In case of comment line */
1267 /* Execute configuration command : this is strict match */
1268 ret
= cmd_execute_command_strict(vline
, vty
, cmd
);
1270 /* The logic for trying parent nodes is in cmd_execute_command_real()
1271 * since calling ->node_exit() correctly is a bit involved. This is
1272 * also the only reason CMD_NO_LEVEL_UP exists.
1274 while (!(use_daemon
&& ret
== CMD_SUCCESS_DAEMON
)
1275 && !(!use_daemon
&& ret
== CMD_ERR_NOTHING_TODO
)
1276 && ret
!= CMD_SUCCESS
&& ret
!= CMD_WARNING
1277 && ret
!= CMD_ERR_AMBIGUOUS
&& ret
!= CMD_ERR_INCOMPLETE
1278 && ret
!= CMD_NOT_MY_INSTANCE
&& ret
!= CMD_WARNING_CONFIG_FAILED
1279 && ret
!= CMD_NO_LEVEL_UP
)
1280 ret
= cmd_execute_command_real(vline
, FILTER_STRICT
, vty
, cmd
,
1283 if (ret
== CMD_NO_LEVEL_UP
)
1284 ret
= CMD_ERR_NO_MATCH
;
1286 if (ret
!= CMD_SUCCESS
&&
1287 ret
!= CMD_WARNING
&&
1288 ret
!= CMD_SUCCESS_DAEMON
) {
1289 struct vty_error
*ve
= XCALLOC(MTYPE_TMP
, sizeof(*ve
));
1291 memcpy(ve
->error_buf
, vty
->buf
, VTY_BUFSIZ
);
1292 ve
->line_num
= line_num
;
1294 vty
->error
= list_new();
1296 listnode_add(vty
->error
, ve
);
1299 cmd_free_strvec(vline
);
1304 /* Configuration make from file. */
1305 int config_from_file(struct vty
*vty
, FILE *fp
, unsigned int *line_num
)
1307 int ret
, error_ret
= 0;
1310 while (fgets(vty
->buf
, VTY_BUFSIZ
, fp
)) {
1313 ret
= command_config_read_one_line(vty
, NULL
, *line_num
, 0);
1315 if (ret
!= CMD_SUCCESS
&& ret
!= CMD_WARNING
1316 && ret
!= CMD_ERR_NOTHING_TODO
)
1327 /* Configuration from terminal */
1328 DEFUN (config_terminal
,
1329 config_terminal_cmd
,
1330 "configure [terminal]",
1331 "Configuration from vty interface\n"
1332 "Configuration terminal\n")
1334 return vty_config_enter(vty
, false, false);
1337 /* Enable command */
1341 "Turn on privileged mode command\n")
1343 /* If enable password is NULL, change to ENABLE_NODE */
1344 if ((host
.enable
== NULL
&& host
.enable_encrypt
== NULL
)
1345 || vty
->type
== VTY_SHELL_SERV
)
1346 vty
->node
= ENABLE_NODE
;
1348 vty
->node
= AUTH_ENABLE_NODE
;
1353 /* Disable command */
1357 "Turn off privileged mode command\n")
1359 if (vty
->node
== ENABLE_NODE
)
1360 vty
->node
= VIEW_NODE
;
1364 /* Down vty node level. */
1368 "Exit current mode and down to previous mode\n")
1374 static int root_on_exit(struct vty
*vty
)
1379 vty
->status
= VTY_CLOSE
;
1383 void cmd_exit(struct vty
*vty
)
1385 struct cmd_node
*cnode
= vector_lookup(cmdvec
, vty
->node
);
1387 if (cnode
->node_exit
) {
1388 if (!cnode
->node_exit(vty
))
1391 if (cnode
->parent_node
)
1392 vty
->node
= cnode
->parent_node
;
1393 if (vty
->xpath_index
> 0 && !cnode
->no_xpath
)
1401 "Exit current mode and down to previous mode\n")
1403 return config_exit(self
, vty
, argc
, argv
);
1407 /* End of configuration. */
1411 "End current mode and change to enable mode.\n")
1414 vty_config_exit(vty
);
1415 vty
->node
= ENABLE_NODE
;
1421 DEFUN (show_version
,
1425 "Displays zebra version\n")
1427 vty_out(vty
, "%s %s (%s) on %s(%s).\n", FRR_FULL_NAME
, FRR_VERSION
,
1428 cmd_hostname_get() ? cmd_hostname_get() : "", cmd_system_get(),
1430 vty_out(vty
, "%s%s\n", FRR_COPYRIGHT
, GIT_INFO
);
1431 #ifdef ENABLE_VERSION_BUILD_CONFIG
1432 vty_out(vty
, "configured with:\n %s\n", FRR_CONFIG_ARGS
);
1437 /* Help display function for all node. */
1441 "Description of the interactive help system\n")
1444 "Quagga VTY provides advanced help feature. When you need help,\n\
1445 anytime at the command line please press '?'.\n\
1447 If nothing matches, the help list will be empty and you must backup\n\
1448 until entering a '?' shows the available options.\n\
1449 Two styles of help are provided:\n\
1450 1. Full help is available when you are ready to enter a\n\
1451 command argument (e.g. 'show ?') and describes each possible\n\
1453 2. Partial help is provided when an abbreviated argument is entered\n\
1454 and you want to know what arguments match the input\n\
1455 (e.g. 'show me?'.)\n\n");
1459 static void permute(struct graph_node
*start
, struct vty
*vty
)
1461 static struct list
*position
= NULL
;
1463 position
= list_new();
1465 struct cmd_token
*stok
= start
->data
;
1466 struct graph_node
*gnn
;
1467 struct listnode
*ln
;
1470 listnode_add(position
, start
);
1471 for (unsigned int i
= 0; i
< vector_active(start
->to
); i
++) {
1472 struct graph_node
*gn
= vector_slot(start
->to
, i
);
1473 struct cmd_token
*tok
= gn
->data
;
1474 if (tok
->attr
== CMD_ATTR_HIDDEN
1475 || tok
->attr
== CMD_ATTR_DEPRECATED
)
1477 else if (tok
->type
== END_TKN
|| gn
== start
) {
1479 for (ALL_LIST_ELEMENTS_RO(position
, ln
, gnn
)) {
1480 struct cmd_token
*tt
= gnn
->data
;
1481 if (tt
->type
< SPECIAL_TKN
)
1482 vty_out(vty
, " %s", tt
->text
);
1485 vty_out(vty
, "...");
1489 if (stok
->type
== FORK_TKN
&& tok
->type
!= FORK_TKN
)
1490 for (ALL_LIST_ELEMENTS_RO(position
, ln
, gnn
))
1499 list_delete_node(position
, listtail(position
));
1502 static void print_cmd(struct vty
*vty
, const char *cmd
)
1504 int i
, j
, len
= strlen(cmd
);
1509 for (i
= 0; i
< len
; i
++) {
1513 else if (strchr(" ()<>[]{}|", cmd
[i
]))
1519 if (isspace(cmd
[i
])) {
1520 /* skip leading whitespace */
1523 /* skip trailing whitespace */
1526 /* skip all whitespace after opening brackets or pipe */
1527 if (strchr("(<[{|", cmd
[i
- 1])) {
1528 while (isspace(cmd
[i
+ 1]))
1532 /* skip repeated whitespace */
1533 if (isspace(cmd
[i
+ 1]))
1535 /* skip whitespace before closing brackets or pipe */
1536 if (strchr(")>]}|", cmd
[i
+ 1]))
1538 /* convert tabs to spaces */
1539 if (cmd
[i
] == '\t') {
1549 vty_out(vty
, "%s\n", buf
);
1552 int cmd_list_cmds(struct vty
*vty
, int do_permute
)
1554 struct cmd_node
*node
= vector_slot(cmdvec
, vty
->node
);
1557 cmd_finalize_node(node
);
1558 permute(vector_slot(node
->cmdgraph
->nodes
, 0), vty
);
1560 /* loop over all commands at this node */
1561 const struct cmd_element
*element
= NULL
;
1562 for (unsigned int i
= 0; i
< vector_active(node
->cmd_vector
);
1564 if ((element
= vector_slot(node
->cmd_vector
, i
))
1565 && element
->attr
!= CMD_ATTR_DEPRECATED
1566 && element
->attr
!= CMD_ATTR_HIDDEN
) {
1568 print_cmd(vty
, element
->string
);
1574 /* Help display function for all node. */
1577 "list [permutations]",
1578 "Print command list\n"
1579 "Print all possible command permutations\n")
1581 return cmd_list_cmds(vty
, argc
== 2);
1584 DEFUN (show_commandtree
,
1585 show_commandtree_cmd
,
1586 "show commandtree [permutations]",
1588 "Show command tree\n"
1589 "Permutations that we are interested in\n")
1591 return cmd_list_cmds(vty
, argc
== 3);
1594 DEFUN_HIDDEN(show_cli_graph
,
1599 "Dump current command space as DOT graph\n")
1601 struct cmd_node
*cn
= vector_slot(cmdvec
, vty
->node
);
1604 cmd_finalize_node(cn
);
1605 dot
= cmd_graph_dump_dot(cn
->cmdgraph
);
1607 vty_out(vty
, "%s\n", dot
);
1608 XFREE(MTYPE_TMP
, dot
);
1612 static int vty_write_config(struct vty
*vty
)
1615 struct cmd_node
*node
;
1620 nb_cli_show_config_prepare(running_config
, false);
1622 if (vty
->type
== VTY_TERM
) {
1623 vty_out(vty
, "\nCurrent configuration:\n");
1624 vty_out(vty
, "!\n");
1627 if (strcmp(frr_defaults_version(), FRR_VER_SHORT
))
1628 vty_out(vty
, "! loaded from %s\n", frr_defaults_version());
1629 vty_out(vty
, "frr version %s\n", FRR_VER_SHORT
);
1630 vty_out(vty
, "frr defaults %s\n", frr_defaults_profile());
1631 vty_out(vty
, "!\n");
1633 for (i
= 0; i
< vector_active(cmdvec
); i
++)
1634 if ((node
= vector_slot(cmdvec
, i
)) && node
->config_write
) {
1635 if ((*node
->config_write
)(vty
))
1636 vty_out(vty
, "!\n");
1639 if (vty
->type
== VTY_TERM
) {
1640 vty_out(vty
, "end\n");
1646 static int file_write_config(struct vty
*vty
)
1649 char *config_file
, *slash
;
1650 char *config_file_tmp
= NULL
;
1651 char *config_file_sav
= NULL
;
1652 int ret
= CMD_WARNING
;
1653 struct vty
*file_vty
;
1654 struct stat conf_stat
;
1659 /* Check and see if we are operating under vtysh configuration */
1660 if (host
.config
== NULL
) {
1662 "Can't save to configuration file, using vtysh.\n");
1667 config_file
= host
.config
;
1670 #define O_DIRECTORY 0
1672 slash
= strrchr(config_file
, '/');
1674 char *config_dir
= XSTRDUP(MTYPE_TMP
, config_file
);
1675 config_dir
[slash
- config_file
] = '\0';
1676 dirfd
= open(config_dir
, O_DIRECTORY
| O_RDONLY
);
1677 XFREE(MTYPE_TMP
, config_dir
);
1679 dirfd
= open(".", O_DIRECTORY
| O_RDONLY
);
1680 /* if dirfd is invalid, directory sync fails, but we're still OK */
1682 size_t config_file_sav_sz
= strlen(config_file
) + strlen(CONF_BACKUP_EXT
) + 1;
1683 config_file_sav
= XMALLOC(MTYPE_TMP
, config_file_sav_sz
);
1684 strlcpy(config_file_sav
, config_file
, config_file_sav_sz
);
1685 strlcat(config_file_sav
, CONF_BACKUP_EXT
, config_file_sav_sz
);
1688 config_file_tmp
= XMALLOC(MTYPE_TMP
, strlen(config_file
) + 8);
1689 snprintf(config_file_tmp
, strlen(config_file
) + 8, "%s.XXXXXX",
1692 /* Open file to configuration write. */
1693 fd
= mkstemp(config_file_tmp
);
1695 vty_out(vty
, "Can't open configuration file %s.\n",
1699 if (fchmod(fd
, CONFIGFILE_MASK
) != 0) {
1700 vty_out(vty
, "Can't chmod configuration file %s: %s (%d).\n",
1701 config_file_tmp
, safe_strerror(errno
), errno
);
1705 /* Make vty for configuration file. */
1706 file_vty
= vty_new();
1708 file_vty
->type
= VTY_FILE
;
1710 /* Config file header print. */
1711 vty_out(file_vty
, "!\n! Zebra configuration saved from vty\n! ");
1712 vty_time_print(file_vty
, 1);
1713 vty_out(file_vty
, "!\n");
1714 vty_write_config(file_vty
);
1715 vty_close(file_vty
);
1717 if (stat(config_file
, &conf_stat
) >= 0) {
1718 if (unlink(config_file_sav
) != 0)
1719 if (errno
!= ENOENT
) {
1721 "Can't unlink backup configuration file %s.\n",
1725 if (link(config_file
, config_file_sav
) != 0) {
1727 "Can't backup old configuration file %s.\n",
1734 if (rename(config_file_tmp
, config_file
) != 0) {
1735 vty_out(vty
, "Can't save configuration file %s.\n",
1742 vty_out(vty
, "Configuration saved to %s\n", config_file
);
1746 if (ret
!= CMD_SUCCESS
)
1747 unlink(config_file_tmp
);
1750 XFREE(MTYPE_TMP
, config_file_tmp
);
1751 XFREE(MTYPE_TMP
, config_file_sav
);
1755 /* Write current configuration into file. */
1757 DEFUN (config_write
,
1759 "write [<file|memory|terminal>]",
1760 "Write running configuration to memory, network, or terminal\n"
1761 "Write to configuration file\n"
1762 "Write configuration currently in memory\n"
1763 "Write configuration to terminal\n")
1765 const int idx_type
= 1;
1767 // if command was 'write terminal' or 'write memory'
1768 if (argc
== 2 && (!strcmp(argv
[idx_type
]->text
, "terminal"))) {
1769 return vty_write_config(vty
);
1772 return file_write_config(vty
);
1775 /* ALIAS_FIXME for 'write <terminal|memory>' */
1776 DEFUN (show_running_config
,
1777 show_running_config_cmd
,
1778 "show running-config",
1780 "running configuration (same as write terminal)\n")
1782 return vty_write_config(vty
);
1785 /* ALIAS_FIXME for 'write file' */
1786 DEFUN (copy_runningconf_startupconf
,
1787 copy_runningconf_startupconf_cmd
,
1788 "copy running-config startup-config",
1789 "Copy configuration\n"
1790 "Copy running config to... \n"
1791 "Copy running config to startup config (same as write file/memory)\n")
1793 return file_write_config(vty
);
1797 /* Write startup configuration into the terminal. */
1798 DEFUN (show_startup_config
,
1799 show_startup_config_cmd
,
1800 "show startup-config",
1802 "Contents of startup configuration\n")
1809 if (host
.config
== NULL
)
1812 confp
= fopen(host
.config
, "r");
1813 if (confp
== NULL
) {
1814 vty_out(vty
, "Can't open configuration file [%s] due to '%s'\n",
1815 host
.config
, safe_strerror(errno
));
1819 while (fgets(buf
, BUFSIZ
, confp
)) {
1822 while (*cp
!= '\r' && *cp
!= '\n' && *cp
!= '\0')
1826 vty_out(vty
, "%s\n", buf
);
1834 int cmd_domainname_set(const char *domainname
)
1836 XFREE(MTYPE_HOST
, host
.domainname
);
1837 host
.domainname
= domainname
? XSTRDUP(MTYPE_HOST
, domainname
) : NULL
;
1841 /* Hostname configuration */
1842 DEFUN(config_domainname
,
1845 "Set system's domain name\n"
1846 "This system's domain name\n")
1848 struct cmd_token
*word
= argv
[1];
1850 if (!isalpha((unsigned char)word
->arg
[0])) {
1851 vty_out(vty
, "Please specify string starting with alphabet\n");
1852 return CMD_WARNING_CONFIG_FAILED
;
1855 return cmd_domainname_set(word
->arg
);
1858 DEFUN(config_no_domainname
,
1860 "no domainname [DOMAINNAME]",
1862 "Reset system's domain name\n"
1863 "domain name of this router\n")
1865 return cmd_domainname_set(NULL
);
1868 int cmd_hostname_set(const char *hostname
)
1870 XFREE(MTYPE_HOST
, host
.name
);
1871 host
.name
= hostname
? XSTRDUP(MTYPE_HOST
, hostname
) : NULL
;
1875 /* Hostname configuration */
1876 DEFUN (config_hostname
,
1879 "Set system's network name\n"
1880 "This system's network name\n")
1882 struct cmd_token
*word
= argv
[1];
1884 if (!isalnum((unsigned char)word
->arg
[0])) {
1886 "Please specify string starting with alphabet or number\n");
1887 return CMD_WARNING_CONFIG_FAILED
;
1890 /* With reference to RFC 1123 Section 2.1 */
1891 if (strlen(word
->arg
) > HOSTNAME_LEN
) {
1892 vty_out(vty
, "Hostname length should be less than %d chars\n",
1894 return CMD_WARNING_CONFIG_FAILED
;
1897 return cmd_hostname_set(word
->arg
);
1900 DEFUN (config_no_hostname
,
1902 "no hostname [HOSTNAME]",
1904 "Reset system's network name\n"
1905 "Host name of this router\n")
1907 return cmd_hostname_set(NULL
);
1910 /* VTY interface password set. */
1911 DEFUN (config_password
,
1913 "password [(8-8)] WORD",
1914 "Modify the terminal connection password\n"
1915 "Specifies a HIDDEN password will follow\n"
1916 "The password string\n")
1920 if (argc
== 3) // '8' was specified
1923 XFREE(MTYPE_HOST
, host
.password
);
1924 host
.password
= NULL
;
1925 if (host
.password_encrypt
)
1926 XFREE(MTYPE_HOST
, host
.password_encrypt
);
1927 host
.password_encrypt
=
1928 XSTRDUP(MTYPE_HOST
, argv
[idx_word
]->arg
);
1932 if (!isalnum((unsigned char)argv
[idx_8
]->arg
[0])) {
1934 "Please specify string starting with alphanumeric\n");
1935 return CMD_WARNING_CONFIG_FAILED
;
1939 XFREE(MTYPE_HOST
, host
.password
);
1940 host
.password
= NULL
;
1943 if (host
.password_encrypt
)
1944 XFREE(MTYPE_HOST
, host
.password_encrypt
);
1945 host
.password_encrypt
=
1946 XSTRDUP(MTYPE_HOST
, zencrypt(argv
[idx_8
]->arg
));
1948 host
.password
= XSTRDUP(MTYPE_HOST
, argv
[idx_8
]->arg
);
1953 /* VTY interface password delete. */
1954 DEFUN (no_config_password
,
1958 "Modify the terminal connection password\n")
1960 bool warned
= false;
1962 if (host
.password
) {
1963 if (!vty_shell_serv(vty
)) {
1964 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
1967 XFREE(MTYPE_HOST
, host
.password
);
1969 host
.password
= NULL
;
1971 if (host
.password_encrypt
) {
1972 if (!warned
&& !vty_shell_serv(vty
))
1973 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
1974 XFREE(MTYPE_HOST
, host
.password_encrypt
);
1976 host
.password_encrypt
= NULL
;
1981 /* VTY enable password set. */
1982 DEFUN (config_enable_password
,
1983 enable_password_cmd
,
1984 "enable password [(8-8)] WORD",
1985 "Modify enable password parameters\n"
1986 "Assign the privileged level password\n"
1987 "Specifies a HIDDEN password will follow\n"
1988 "The HIDDEN 'enable' password string\n")
1993 /* Crypt type is specified. */
1995 if (argv
[idx_8
]->arg
[0] == '8') {
1997 XFREE(MTYPE_HOST
, host
.enable
);
2000 if (host
.enable_encrypt
)
2001 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2002 host
.enable_encrypt
=
2003 XSTRDUP(MTYPE_HOST
, argv
[idx_word
]->arg
);
2007 vty_out(vty
, "Unknown encryption type.\n");
2008 return CMD_WARNING_CONFIG_FAILED
;
2012 if (!isalnum((unsigned char)argv
[idx_8
]->arg
[0])) {
2014 "Please specify string starting with alphanumeric\n");
2015 return CMD_WARNING_CONFIG_FAILED
;
2019 XFREE(MTYPE_HOST
, host
.enable
);
2022 /* Plain password input. */
2024 if (host
.enable_encrypt
)
2025 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2026 host
.enable_encrypt
=
2027 XSTRDUP(MTYPE_HOST
, zencrypt(argv
[idx_8
]->arg
));
2029 host
.enable
= XSTRDUP(MTYPE_HOST
, argv
[idx_8
]->arg
);
2034 /* VTY enable password delete. */
2035 DEFUN (no_config_enable_password
,
2036 no_enable_password_cmd
,
2037 "no enable password",
2039 "Modify enable password parameters\n"
2040 "Assign the privileged level password\n")
2042 bool warned
= false;
2045 if (!vty_shell_serv(vty
)) {
2046 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
2049 XFREE(MTYPE_HOST
, host
.enable
);
2053 if (host
.enable_encrypt
) {
2054 if (!warned
&& !vty_shell_serv(vty
))
2055 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
2056 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2058 host
.enable_encrypt
= NULL
;
2063 DEFUN (service_password_encrypt
,
2064 service_password_encrypt_cmd
,
2065 "service password-encryption",
2066 "Set up miscellaneous service\n"
2067 "Enable encrypted passwords\n")
2074 if (host
.password
) {
2075 if (host
.password_encrypt
)
2076 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2077 host
.password_encrypt
=
2078 XSTRDUP(MTYPE_HOST
, zencrypt(host
.password
));
2081 if (host
.enable_encrypt
)
2082 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2083 host
.enable_encrypt
=
2084 XSTRDUP(MTYPE_HOST
, zencrypt(host
.enable
));
2090 DEFUN (no_service_password_encrypt
,
2091 no_service_password_encrypt_cmd
,
2092 "no service password-encryption",
2094 "Set up miscellaneous service\n"
2095 "Enable encrypted passwords\n")
2102 if (host
.password_encrypt
)
2103 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2104 host
.password_encrypt
= NULL
;
2106 if (host
.enable_encrypt
)
2107 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2108 host
.enable_encrypt
= NULL
;
2113 DEFUN (config_terminal_length
,
2114 config_terminal_length_cmd
,
2115 "terminal length (0-512)",
2116 "Set terminal line parameters\n"
2117 "Set number of lines on a screen\n"
2118 "Number of lines on screen (0 for no pausing)\n")
2122 vty
->lines
= atoi(argv
[idx_number
]->arg
);
2127 DEFUN (config_terminal_no_length
,
2128 config_terminal_no_length_cmd
,
2129 "terminal no length",
2130 "Set terminal line parameters\n"
2132 "Set number of lines on a screen\n")
2138 DEFUN (service_terminal_length
,
2139 service_terminal_length_cmd
,
2140 "service terminal-length (0-512)",
2141 "Set up miscellaneous service\n"
2142 "System wide terminal length configuration\n"
2143 "Number of lines of VTY (0 means no line control)\n")
2147 host
.lines
= atoi(argv
[idx_number
]->arg
);
2152 DEFUN (no_service_terminal_length
,
2153 no_service_terminal_length_cmd
,
2154 "no service terminal-length [(0-512)]",
2156 "Set up miscellaneous service\n"
2157 "System wide terminal length configuration\n"
2158 "Number of lines of VTY (0 means no line control)\n")
2164 DEFUN_HIDDEN (do_echo
,
2167 "Echo a message back to the vty\n"
2168 "The message to echo\n")
2172 vty_out(vty
, "%s\n",
2173 ((message
= argv_concat(argv
, argc
, 1)) ? message
: ""));
2175 XFREE(MTYPE_TMP
, message
);
2179 DEFUN (config_logmsg
,
2181 "logmsg <emergencies|alerts|critical|errors|warnings|notifications|informational|debugging> MESSAGE...",
2182 "Send a message to enabled logging destinations\n"
2184 "The message to send\n")
2186 int idx_log_level
= 1;
2187 int idx_message
= 2;
2191 level
= log_level_match(argv
[idx_log_level
]->arg
);
2192 if (level
== ZLOG_DISABLED
)
2193 return CMD_ERR_NO_MATCH
;
2196 ((message
= argv_concat(argv
, argc
, idx_message
)) ? message
: ""));
2198 XFREE(MTYPE_TMP
, message
);
2203 DEFUN (debug_memstats
,
2205 "[no] debug memstats-at-exit",
2208 "Print memory type statistics at exit\n")
2210 debug_memstats_at_exit
= !!strcmp(argv
[0]->text
, "no");
2214 int cmd_banner_motd_file(const char *file
)
2216 int success
= CMD_SUCCESS
;
2221 rpath
= realpath(file
, p
);
2223 return CMD_ERR_NO_FILE
;
2224 in
= strstr(rpath
, SYSCONFDIR
);
2226 XFREE(MTYPE_HOST
, host
.motdfile
);
2227 host
.motdfile
= XSTRDUP(MTYPE_HOST
, file
);
2229 success
= CMD_WARNING_CONFIG_FAILED
;
2234 void cmd_banner_motd_line(const char *line
)
2236 XFREE(MTYPE_HOST
, host
.motd
);
2237 host
.motd
= XSTRDUP(MTYPE_HOST
, line
);
2240 DEFUN (banner_motd_file
,
2241 banner_motd_file_cmd
,
2242 "banner motd file FILE",
2245 "Banner from a file\n"
2249 const char *filename
= argv
[idx_file
]->arg
;
2250 int cmd
= cmd_banner_motd_file(filename
);
2252 if (cmd
== CMD_ERR_NO_FILE
)
2253 vty_out(vty
, "%s does not exist\n", filename
);
2254 else if (cmd
== CMD_WARNING_CONFIG_FAILED
)
2255 vty_out(vty
, "%s must be in %s\n", filename
, SYSCONFDIR
);
2260 DEFUN (banner_motd_line
,
2261 banner_motd_line_cmd
,
2262 "banner motd line LINE...",
2265 "Banner from an input\n"
2271 argv_find(argv
, argc
, "LINE", &idx
);
2272 motd
= argv_concat(argv
, argc
, idx
);
2274 cmd_banner_motd_line(motd
);
2275 XFREE(MTYPE_TMP
, motd
);
2280 DEFUN (banner_motd_default
,
2281 banner_motd_default_cmd
,
2282 "banner motd default",
2283 "Set banner string\n"
2284 "Strings for motd\n"
2287 cmd_banner_motd_line(FRR_DEFAULT_MOTD
);
2291 DEFUN (no_banner_motd
,
2295 "Set banner string\n"
2296 "Strings for motd\n")
2300 XFREE(MTYPE_HOST
, host
.motdfile
);
2301 host
.motdfile
= NULL
;
2305 DEFUN(allow_reserved_ranges
, allow_reserved_ranges_cmd
, "allow-reserved-ranges",
2306 "Allow using IPv4 (Class E) reserved IP space\n")
2308 host
.allow_reserved_ranges
= true;
2312 DEFUN(no_allow_reserved_ranges
, no_allow_reserved_ranges_cmd
,
2313 "no allow-reserved-ranges",
2314 NO_STR
"Allow using IPv4 (Class E) reserved IP space\n")
2316 host
.allow_reserved_ranges
= false;
2320 int cmd_find_cmds(struct vty
*vty
, struct cmd_token
**argv
, int argc
)
2322 const struct cmd_node
*node
;
2323 const struct cmd_element
*cli
;
2328 char *pattern
= argv_concat(argv
, argc
, 1);
2329 int cr
= regcomp(&exp
, pattern
, REG_NOSUB
| REG_EXTENDED
);
2330 XFREE(MTYPE_TMP
, pattern
);
2335 vty_out(vty
, "%% Invalid {...} expression\n");
2338 vty_out(vty
, "%% Bad repetition operator\n");
2341 vty_out(vty
, "%% Regex syntax error\n");
2344 vty_out(vty
, "%% Invalid collating element\n");
2347 vty_out(vty
, "%% Invalid character class name\n");
2351 "%% Regex ended with escape character (\\)\n");
2355 "%% Invalid number in \\digit construction\n");
2358 vty_out(vty
, "%% Unbalanced square brackets\n");
2361 vty_out(vty
, "%% Unbalanced parentheses\n");
2364 vty_out(vty
, "%% Unbalanced braces\n");
2368 "%% Invalid endpoint in range expression\n");
2371 vty_out(vty
, "%% Failed to compile (out of memory)\n");
2379 for (unsigned int i
= 0; i
< vector_active(cmdvec
); i
++) {
2380 node
= vector_slot(cmdvec
, i
);
2383 clis
= node
->cmd_vector
;
2384 for (unsigned int j
= 0; j
< vector_active(clis
); j
++) {
2385 cli
= vector_slot(clis
, j
);
2387 if (regexec(&exp
, cli
->string
, 0, NULL
, 0) == 0) {
2388 vty_out(vty
, " (%s) ", node
->name
);
2389 print_cmd(vty
, cli
->string
);
2402 "Find CLI command matching a regular expression\n"
2403 "Search pattern (POSIX regex)\n")
2405 return cmd_find_cmds(vty
, argv
, argc
);
2408 #if defined(DEV_BUILD) && defined(HAVE_SCRIPTING)
2409 DEFUN(script
, script_cmd
, "script SCRIPT FUNCTION",
2410 "Test command - execute a function in a script\n"
2411 "Script name (same as filename in /etc/frr/scripts/)\n"
2412 "Function name (in the script)\n")
2416 (void)str2prefix("1.2.3.4/24", &p
);
2417 struct frrscript
*fs
= frrscript_new(argv
[1]->arg
);
2419 if (frrscript_load(fs
, argv
[2]->arg
, NULL
)) {
2421 "/etc/frr/scripts/%s.lua or function '%s' not found\n",
2422 argv
[1]->arg
, argv
[2]->arg
);
2425 int ret
= frrscript_call(fs
, argv
[2]->arg
, ("p", &p
));
2427 prefix2str(&p
, buf
, sizeof(buf
));
2428 vty_out(vty
, "p: %s\n", buf
);
2429 vty_out(vty
, "Script result: %d\n", ret
);
2431 frrscript_delete(fs
);
2437 /* Set config filename. Called from vty.c */
2438 void host_config_set(const char *filename
)
2440 XFREE(MTYPE_HOST
, host
.config
);
2441 host
.config
= XSTRDUP(MTYPE_HOST
, filename
);
2444 const char *host_config_get(void)
2449 void install_default(enum node_type node
)
2451 _install_element(node
, &config_exit_cmd
);
2452 _install_element(node
, &config_quit_cmd
);
2453 _install_element(node
, &config_end_cmd
);
2454 _install_element(node
, &config_help_cmd
);
2455 _install_element(node
, &config_list_cmd
);
2456 _install_element(node
, &show_cli_graph_cmd
);
2457 _install_element(node
, &find_cmd
);
2459 _install_element(node
, &config_write_cmd
);
2460 _install_element(node
, &show_running_config_cmd
);
2462 _install_element(node
, &autocomplete_cmd
);
2464 nb_cli_install_default(node
);
2467 /* Initialize command interface. Install basic nodes and commands.
2469 * terminal = 0 -- vtysh / no logging, no config control
2470 * terminal = 1 -- normal daemon
2471 * terminal = -1 -- watchfrr / no logging, but minimal config control */
2472 void cmd_init(int terminal
)
2474 struct utsname names
;
2479 /* register command preprocessors */
2480 hook_register(cmd_execute
, handle_pipe_action
);
2481 hook_register(cmd_execute_done
, handle_pipe_action_done
);
2483 varhandlers
= list_new();
2485 /* Allocate initial top vector of commands. */
2486 cmdvec
= vector_init(VECTOR_MIN_SIZE
);
2488 /* Default host value settings. */
2489 host
.name
= XSTRDUP(MTYPE_HOST
, names
.nodename
);
2490 host
.system
= XSTRDUP(MTYPE_HOST
, names
.sysname
);
2491 host
.release
= XSTRDUP(MTYPE_HOST
, names
.release
);
2492 host
.version
= XSTRDUP(MTYPE_HOST
, names
.version
);
2494 #ifdef HAVE_STRUCT_UTSNAME_DOMAINNAME
2495 if ((strcmp(names
.domainname
, "(none)") == 0))
2496 host
.domainname
= NULL
;
2498 host
.domainname
= XSTRDUP(MTYPE_HOST
, names
.domainname
);
2500 host
.domainname
= NULL
;
2502 host
.password
= NULL
;
2505 host
.noconfig
= (terminal
< 0);
2507 cmd_banner_motd_line(FRR_DEFAULT_MOTD
);
2508 host
.motdfile
= NULL
;
2509 host
.allow_reserved_ranges
= false;
2511 /* Install top nodes. */
2512 install_node(&view_node
);
2513 install_node(&enable_node
);
2514 install_node(&auth_node
);
2515 install_node(&auth_enable_node
);
2516 install_node(&config_node
);
2518 /* Each node's basic commands. */
2519 install_element(VIEW_NODE
, &show_version_cmd
);
2520 install_element(ENABLE_NODE
, &show_startup_config_cmd
);
2523 install_element(ENABLE_NODE
, &debug_memstats_cmd
);
2525 install_element(VIEW_NODE
, &config_list_cmd
);
2526 install_element(VIEW_NODE
, &config_exit_cmd
);
2527 install_element(VIEW_NODE
, &config_quit_cmd
);
2528 install_element(VIEW_NODE
, &config_help_cmd
);
2529 install_element(VIEW_NODE
, &config_enable_cmd
);
2530 install_element(VIEW_NODE
, &config_terminal_length_cmd
);
2531 install_element(VIEW_NODE
, &config_terminal_no_length_cmd
);
2532 install_element(VIEW_NODE
, &show_commandtree_cmd
);
2533 install_element(VIEW_NODE
, &echo_cmd
);
2534 install_element(VIEW_NODE
, &autocomplete_cmd
);
2535 install_element(VIEW_NODE
, &find_cmd
);
2536 #if defined(DEV_BUILD) && defined(HAVE_SCRIPTING)
2537 install_element(VIEW_NODE
, &script_cmd
);
2541 install_element(ENABLE_NODE
, &config_end_cmd
);
2542 install_element(ENABLE_NODE
, &config_disable_cmd
);
2543 install_element(ENABLE_NODE
, &config_terminal_cmd
);
2544 install_element(ENABLE_NODE
, ©_runningconf_startupconf_cmd
);
2545 install_element(ENABLE_NODE
, &config_write_cmd
);
2546 install_element(ENABLE_NODE
, &show_running_config_cmd
);
2547 install_element(ENABLE_NODE
, &config_logmsg_cmd
);
2549 install_default(CONFIG_NODE
);
2552 workqueue_cmd_init();
2556 install_element(CONFIG_NODE
, &hostname_cmd
);
2557 install_element(CONFIG_NODE
, &no_hostname_cmd
);
2558 install_element(CONFIG_NODE
, &domainname_cmd
);
2559 install_element(CONFIG_NODE
, &no_domainname_cmd
);
2564 install_element(CONFIG_NODE
, &debug_memstats_cmd
);
2566 install_element(CONFIG_NODE
, &password_cmd
);
2567 install_element(CONFIG_NODE
, &no_password_cmd
);
2568 install_element(CONFIG_NODE
, &enable_password_cmd
);
2569 install_element(CONFIG_NODE
, &no_enable_password_cmd
);
2571 install_element(CONFIG_NODE
, &service_password_encrypt_cmd
);
2572 install_element(CONFIG_NODE
, &no_service_password_encrypt_cmd
);
2573 install_element(CONFIG_NODE
, &banner_motd_default_cmd
);
2574 install_element(CONFIG_NODE
, &banner_motd_file_cmd
);
2575 install_element(CONFIG_NODE
, &banner_motd_line_cmd
);
2576 install_element(CONFIG_NODE
, &no_banner_motd_cmd
);
2577 install_element(CONFIG_NODE
, &service_terminal_length_cmd
);
2578 install_element(CONFIG_NODE
, &no_service_terminal_length_cmd
);
2579 install_element(CONFIG_NODE
, &allow_reserved_ranges_cmd
);
2580 install_element(CONFIG_NODE
, &no_allow_reserved_ranges_cmd
);
2583 vrf_install_commands();
2587 grammar_sandbox_init();
2591 void cmd_terminate(void)
2593 struct cmd_node
*cmd_node
;
2595 hook_unregister(cmd_execute
, handle_pipe_action
);
2596 hook_unregister(cmd_execute_done
, handle_pipe_action_done
);
2599 for (unsigned int i
= 0; i
< vector_active(cmdvec
); i
++)
2600 if ((cmd_node
= vector_slot(cmdvec
, i
)) != NULL
) {
2601 // deleting the graph delets the cmd_element as
2603 graph_delete_graph(cmd_node
->cmdgraph
);
2604 vector_free(cmd_node
->cmd_vector
);
2605 hash_clean(cmd_node
->cmd_hash
, NULL
);
2606 hash_free(cmd_node
->cmd_hash
);
2607 cmd_node
->cmd_hash
= NULL
;
2610 vector_free(cmdvec
);
2614 XFREE(MTYPE_HOST
, host
.name
);
2615 XFREE(MTYPE_HOST
, host
.system
);
2616 XFREE(MTYPE_HOST
, host
.release
);
2617 XFREE(MTYPE_HOST
, host
.version
);
2618 XFREE(MTYPE_HOST
, host
.domainname
);
2619 XFREE(MTYPE_HOST
, host
.password
);
2620 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2621 XFREE(MTYPE_HOST
, host
.enable
);
2622 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2623 XFREE(MTYPE_HOST
, host
.motdfile
);
2624 XFREE(MTYPE_HOST
, host
.config
);
2625 XFREE(MTYPE_HOST
, host
.motd
);
2627 list_delete(&varhandlers
);