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 static int root_on_exit(struct vty
*vty
);
126 /* Standard command node structures. */
127 static struct cmd_node auth_node
= {
130 .prompt
= "Password: ",
133 static struct cmd_node view_node
= {
137 .node_exit
= root_on_exit
,
140 static struct cmd_node auth_enable_node
= {
141 .name
= "auth enable",
142 .node
= AUTH_ENABLE_NODE
,
143 .prompt
= "Password: ",
146 static struct cmd_node enable_node
= {
150 .node_exit
= root_on_exit
,
153 static int config_write_host(struct vty
*vty
);
154 static struct cmd_node config_node
= {
157 .parent_node
= ENABLE_NODE
,
158 .prompt
= "%s(config)# ",
159 .config_write
= config_write_host
,
160 .node_exit
= vty_config_node_exit
,
163 /* This is called from main when a daemon is invoked with -v or --version. */
164 void print_version(const char *progname
)
166 printf("%s version %s\n", progname
, FRR_VERSION
);
167 printf("%s\n", FRR_COPYRIGHT
);
168 #ifdef ENABLE_VERSION_BUILD_CONFIG
169 printf("configured with:\n\t%s\n", FRR_CONFIG_ARGS
);
173 char *argv_concat(struct cmd_token
**argv
, int argc
, int shift
)
175 int cnt
= MAX(argc
- shift
, 0);
176 const char *argstr
[cnt
+ 1];
181 for (int i
= 0; i
< cnt
; i
++)
182 argstr
[i
] = argv
[i
+ shift
]->arg
;
184 return frrstr_join(argstr
, cnt
, " ");
187 vector
cmd_make_strvec(const char *string
)
192 const char *copy
= string
;
194 /* skip leading whitespace */
195 while (isspace((unsigned char)*copy
) && *copy
!= '\0')
198 /* if the entire string was whitespace or a comment, return */
199 if (*copy
== '\0' || *copy
== '!' || *copy
== '#')
202 vector result
= frrstr_split_vec(copy
, "\n\r\t ");
204 for (unsigned int i
= 0; i
< vector_active(result
); i
++) {
205 if (strlen(vector_slot(result
, i
)) == 0) {
206 XFREE(MTYPE_TMP
, vector_slot(result
, i
));
207 vector_unset(result
, i
);
211 vector_compact(result
);
216 void cmd_free_strvec(vector v
)
218 frrstr_strvec_free(v
);
222 * Convenience function for accessing argv data.
226 * @param text definition snippet of the desired token
227 * @param index the starting index, and where to store the
228 * index of the found token if it exists
229 * @return 1 if found, 0 otherwise
231 int argv_find(struct cmd_token
**argv
, int argc
, const char *text
, int *index
)
234 for (int i
= *index
; i
< argc
&& found
== 0; i
++)
235 if ((found
= strmatch(text
, argv
[i
]->text
)))
240 static unsigned int cmd_hash_key(const void *p
)
242 int size
= sizeof(p
);
244 return jhash(p
, size
, 0);
247 static bool cmd_hash_cmp(const void *a
, const void *b
)
252 /* Install top node of command vector. */
253 void install_node(struct cmd_node
*node
)
255 #define CMD_HASH_STR_SIZE 256
256 char hash_name
[CMD_HASH_STR_SIZE
];
258 vector_set_index(cmdvec
, node
->node
, node
);
259 node
->cmdgraph
= graph_new();
260 node
->cmd_vector
= vector_init(VECTOR_MIN_SIZE
);
262 struct cmd_token
*token
=
263 cmd_token_new(START_TKN
, CMD_ATTR_NORMAL
, NULL
, NULL
);
264 graph_new_node(node
->cmdgraph
, token
,
265 (void (*)(void *)) & cmd_token_del
);
267 snprintf(hash_name
, sizeof(hash_name
), "Command Hash: %s", node
->name
);
269 hash_create_size(16, cmd_hash_key
, cmd_hash_cmp
, hash_name
);
272 /* Return prompt character of specified node. */
273 const char *cmd_prompt(enum node_type node
)
275 struct cmd_node
*cnode
;
277 cnode
= vector_slot(cmdvec
, node
);
278 return cnode
->prompt
;
281 void cmd_defer_tree(bool val
)
283 defer_cli_tree
= val
;
286 /* Install a command into a node. */
287 void _install_element(enum node_type ntype
, const struct cmd_element
*cmd
)
289 struct cmd_node
*cnode
;
291 /* cmd_init hasn't been called */
293 fprintf(stderr
, "%s called before cmd_init, breakage likely\n",
298 cnode
= vector_lookup(cmdvec
, ntype
);
303 "\tnode %d does not exist.\n"
304 "\tplease call install_node() before install_element()\n",
305 cmd
->name
, cmd
->string
, ntype
);
309 if (hash_lookup(cnode
->cmd_hash
, (void *)cmd
) != NULL
) {
312 "\tnode %d (%s) already has this command installed.\n"
313 "\tduplicate install_element call?\n",
314 cmd
->name
, cmd
->string
, ntype
, cnode
->name
);
318 (void)hash_get(cnode
->cmd_hash
, (void *)cmd
, hash_alloc_intern
);
320 if (cnode
->graph_built
|| !defer_cli_tree
) {
321 struct graph
*graph
= graph_new();
322 struct cmd_token
*token
=
323 cmd_token_new(START_TKN
, CMD_ATTR_NORMAL
, NULL
, NULL
);
324 graph_new_node(graph
, token
,
325 (void (*)(void *)) & cmd_token_del
);
327 cmd_graph_parse(graph
, cmd
);
328 cmd_graph_names(graph
);
329 cmd_graph_merge(cnode
->cmdgraph
, graph
, +1);
330 graph_delete_graph(graph
);
332 cnode
->graph_built
= true;
335 vector_set(cnode
->cmd_vector
, (void *)cmd
);
337 if (ntype
== VIEW_NODE
)
338 _install_element(ENABLE_NODE
, cmd
);
341 static void cmd_finalize_iter(struct hash_bucket
*hb
, void *arg
)
343 struct cmd_node
*cnode
= arg
;
344 const struct cmd_element
*cmd
= hb
->data
;
345 struct graph
*graph
= graph_new();
346 struct cmd_token
*token
=
347 cmd_token_new(START_TKN
, CMD_ATTR_NORMAL
, NULL
, NULL
);
349 graph_new_node(graph
, token
, (void (*)(void *)) & cmd_token_del
);
351 cmd_graph_parse(graph
, cmd
);
352 cmd_graph_names(graph
);
353 cmd_graph_merge(cnode
->cmdgraph
, graph
, +1);
354 graph_delete_graph(graph
);
357 void cmd_finalize_node(struct cmd_node
*cnode
)
359 if (cnode
->graph_built
)
362 hash_iterate(cnode
->cmd_hash
, cmd_finalize_iter
, cnode
);
363 cnode
->graph_built
= true;
366 void uninstall_element(enum node_type ntype
, const struct cmd_element
*cmd
)
368 struct cmd_node
*cnode
;
370 /* cmd_init hasn't been called */
372 fprintf(stderr
, "%s called before cmd_init, breakage likely\n",
377 cnode
= vector_lookup(cmdvec
, ntype
);
382 "\tnode %d does not exist.\n"
383 "\tplease call install_node() before uninstall_element()\n",
384 cmd
->name
, cmd
->string
, ntype
);
388 if (hash_release(cnode
->cmd_hash
, (void *)cmd
) == NULL
) {
391 "\tnode %d (%s) does not have this command installed.\n"
392 "\tduplicate uninstall_element call?\n",
393 cmd
->name
, cmd
->string
, ntype
, cnode
->name
);
397 vector_unset_value(cnode
->cmd_vector
, (void *)cmd
);
399 if (cnode
->graph_built
) {
400 struct graph
*graph
= graph_new();
401 struct cmd_token
*token
=
402 cmd_token_new(START_TKN
, CMD_ATTR_NORMAL
, NULL
, NULL
);
403 graph_new_node(graph
, token
,
404 (void (*)(void *)) & cmd_token_del
);
406 cmd_graph_parse(graph
, cmd
);
407 cmd_graph_names(graph
);
408 cmd_graph_merge(cnode
->cmdgraph
, graph
, -1);
409 graph_delete_graph(graph
);
412 if (ntype
== VIEW_NODE
)
413 uninstall_element(ENABLE_NODE
, cmd
);
417 static const unsigned char itoa64
[] =
418 "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
420 static void to64(char *s
, long v
, int n
)
423 *s
++ = itoa64
[v
& 0x3f];
428 static char *zencrypt(const char *passwd
)
432 char *crypt(const char *, const char *);
434 gettimeofday(&tv
, 0);
436 to64(&salt
[0], frr_weak_random(), 3);
437 to64(&salt
[3], tv
.tv_usec
, 3);
440 return crypt(passwd
, salt
);
443 static bool full_cli
;
445 /* This function write configuration of this host. */
446 static int config_write_host(struct vty
*vty
)
450 name
= cmd_hostname_get();
451 if (name
&& name
[0] != '\0')
452 vty_out(vty
, "hostname %s\n", name
);
454 name
= cmd_domainname_get();
455 if (name
&& name
[0] != '\0')
456 vty_out(vty
, "domainname %s\n", name
);
458 /* The following are all configuration commands that are not sent to
459 * watchfrr. For instance watchfrr is hardcoded to log to syslog so
460 * we would always display 'log syslog informational' in the config
461 * which would cause other daemons to then switch to syslog when they
466 if (host
.password_encrypt
)
467 vty_out(vty
, "password 8 %s\n",
468 host
.password_encrypt
);
469 if (host
.enable_encrypt
)
470 vty_out(vty
, "enable password 8 %s\n",
471 host
.enable_encrypt
);
474 vty_out(vty
, "password %s\n", host
.password
);
476 vty_out(vty
, "enable password %s\n",
479 log_config_write(vty
);
481 /* print disable always, but enable only if default is flipped
482 * => prep for future removal of compile-time knob
484 if (!cputime_enabled
)
485 vty_out(vty
, "no service cputime-stats\n");
486 #ifdef EXCLUDE_CPU_TIME
488 vty_out(vty
, "service cputime-stats\n");
491 if (!cputime_threshold
)
492 vty_out(vty
, "no service cputime-warning\n");
493 #if defined(CONSUMED_TIME_CHECK) && CONSUMED_TIME_CHECK != 5000000
494 else /* again, always print non-default */
496 else if (cputime_threshold
!= 5000000)
498 vty_out(vty
, "service cputime-warning %lu\n",
501 if (!walltime_threshold
)
502 vty_out(vty
, "no service walltime-warning\n");
503 #if defined(CONSUMED_TIME_CHECK) && CONSUMED_TIME_CHECK != 5000000
504 else /* again, always print non-default */
506 else if (walltime_threshold
!= 5000000)
508 vty_out(vty
, "service walltime-warning %lu\n",
512 vty_out(vty
, "service advanced-vty\n");
515 vty_out(vty
, "service password-encryption\n");
518 vty_out(vty
, "service terminal-length %d\n",
522 vty_out(vty
, "banner motd file %s\n", host
.motdfile
);
524 && strncmp(host
.motd
, FRR_DEFAULT_MOTD
,
526 vty_out(vty
, "banner motd line %s\n", host
.motd
);
528 vty_out(vty
, "no banner motd\n");
531 if (debug_memstats_at_exit
)
532 vty_out(vty
, "!\ndebug memstats-at-exit\n");
537 /* Utility function for getting command graph. */
538 static struct graph
*cmd_node_graph(vector v
, enum node_type ntype
)
540 struct cmd_node
*cnode
= vector_slot(v
, ntype
);
542 cmd_finalize_node(cnode
);
543 return cnode
->cmdgraph
;
546 static int cmd_try_do_shortcut(enum node_type node
, char *first_word
)
548 if (first_word
!= NULL
&& node
!= AUTH_NODE
&& node
!= VIEW_NODE
549 && node
!= AUTH_ENABLE_NODE
&& 0 == strcmp("do", first_word
))
555 * Compare function for cmd_token.
556 * Used with qsort to sort command completions.
558 static int compare_completions(const void *fst
, const void *snd
)
560 const struct cmd_token
*first
= *(const struct cmd_token
* const *)fst
,
561 *secnd
= *(const struct cmd_token
* const *)snd
;
562 return strcmp(first
->text
, secnd
->text
);
566 * Takes a list of completions returned by command_complete,
567 * dedeuplicates them based on both text and description,
568 * sorts them, and returns them as a vector.
570 * @param completions linked list of cmd_token
571 * @return deduplicated and sorted vector with
573 vector
completions_to_vec(struct list
*completions
)
575 vector comps
= vector_init(VECTOR_MIN_SIZE
);
578 struct cmd_token
*token
, *cr
= NULL
;
579 unsigned int i
, exists
;
580 for (ALL_LIST_ELEMENTS_RO(completions
, ln
, token
)) {
581 if (token
->type
== END_TKN
&& (cr
= token
))
584 // linear search for token in completions vector
586 for (i
= 0; i
< vector_active(comps
) && !exists
; i
++) {
587 struct cmd_token
*curr
= vector_slot(comps
, i
);
589 exists
= !strcmp(curr
->text
, token
->text
)
590 && !strcmp(curr
->desc
, token
->desc
);
592 exists
= !strcmp(curr
->text
, token
->text
);
593 #endif /* VTYSH_DEBUG */
597 vector_set(comps
, token
);
601 qsort(comps
->index
, vector_active(comps
), sizeof(void *),
602 &compare_completions
);
604 // make <cr> the first element, if it is present
606 vector_set_index(comps
, vector_active(comps
), NULL
);
607 memmove(comps
->index
+ 1, comps
->index
,
608 (comps
->alloced
- 1) * sizeof(void *));
609 vector_set_index(comps
, 0, cr
);
615 * Generates a vector of cmd_token representing possible completions
616 * on the current input.
618 * @param vline the vectorized input line
619 * @param vty the vty with the node to match on
620 * @param status pointer to matcher status code
621 * @return vector of struct cmd_token * with possible completions
623 static vector
cmd_complete_command_real(vector vline
, struct vty
*vty
,
626 struct list
*completions
;
627 struct graph
*cmdgraph
= cmd_node_graph(cmdvec
, vty
->node
);
629 enum matcher_rv rv
= command_complete(cmdgraph
, vline
, &completions
);
631 if (MATCHER_ERROR(rv
)) {
632 *status
= CMD_ERR_NO_MATCH
;
636 vector comps
= completions_to_vec(completions
);
637 list_delete(&completions
);
639 // set status code appropriately
640 switch (vector_active(comps
)) {
642 *status
= CMD_ERR_NO_MATCH
;
645 *status
= CMD_COMPLETE_FULL_MATCH
;
648 *status
= CMD_COMPLETE_LIST_MATCH
;
654 vector
cmd_describe_command(vector vline
, struct vty
*vty
, int *status
)
658 if (cmd_try_do_shortcut(vty
->node
, vector_slot(vline
, 0))) {
659 enum node_type onode
;
660 int orig_xpath_index
;
661 vector shifted_vline
;
665 orig_xpath_index
= vty
->xpath_index
;
666 vty
->node
= ENABLE_NODE
;
667 vty
->xpath_index
= 0;
668 /* We can try it on enable node, cos' the vty is authenticated
671 shifted_vline
= vector_init(vector_count(vline
));
673 for (index
= 1; index
< vector_active(vline
); index
++) {
674 vector_set_index(shifted_vline
, index
- 1,
675 vector_lookup(vline
, index
));
678 ret
= cmd_complete_command_real(shifted_vline
, vty
, status
);
680 vector_free(shifted_vline
);
682 vty
->xpath_index
= orig_xpath_index
;
686 return cmd_complete_command_real(vline
, vty
, status
);
689 static struct list
*varhandlers
= NULL
;
691 void cmd_variable_complete(struct cmd_token
*token
, const char *arg
,
695 const struct cmd_variable_handler
*cvh
;
699 tmpcomps
= arg
? vector_init(VECTOR_MIN_SIZE
) : comps
;
701 for (ALL_LIST_ELEMENTS_RO(varhandlers
, ln
, cvh
)) {
702 if (cvh
->tokenname
&& strcmp(cvh
->tokenname
, token
->text
))
704 if (cvh
->varname
&& (!token
->varname
705 || strcmp(cvh
->varname
, token
->varname
)))
707 cvh
->completions(tmpcomps
, token
);
715 for (i
= vector_active(tmpcomps
); i
; i
--) {
716 char *item
= vector_slot(tmpcomps
, i
- 1);
717 if (strlen(item
) >= argsz
&& !strncmp(item
, arg
, argsz
))
718 vector_set(comps
, item
);
720 XFREE(MTYPE_COMPLETION
, item
);
722 vector_free(tmpcomps
);
725 #define AUTOCOMP_INDENT 5
727 char *cmd_variable_comp2str(vector comps
, unsigned short cols
)
730 char *buf
= XCALLOC(MTYPE_TMP
, bsz
);
731 int lc
= AUTOCOMP_INDENT
;
732 size_t cs
= AUTOCOMP_INDENT
;
734 snprintf(buf
, bsz
, "%*s", AUTOCOMP_INDENT
, "");
735 for (size_t j
= 0; j
< vector_active(comps
); j
++) {
736 char *item
= vector_slot(comps
, j
);
737 itemlen
= strlen(item
);
739 if (cs
+ itemlen
+ AUTOCOMP_INDENT
+ 3 >= bsz
)
740 buf
= XREALLOC(MTYPE_TMP
, buf
, (bsz
*= 2));
742 if (lc
+ itemlen
+ 1 >= cols
) {
743 cs
+= snprintf(&buf
[cs
], bsz
- cs
, "\n%*s",
744 AUTOCOMP_INDENT
, "");
745 lc
= AUTOCOMP_INDENT
;
748 size_t written
= snprintf(&buf
[cs
], bsz
- cs
, "%s ", item
);
751 XFREE(MTYPE_COMPLETION
, item
);
752 vector_set_index(comps
, j
, NULL
);
757 void cmd_variable_handler_register(const struct cmd_variable_handler
*cvh
)
762 for (; cvh
->completions
; cvh
++)
763 listnode_add(varhandlers
, (void *)cvh
);
766 DEFUN_HIDDEN (autocomplete
,
768 "autocomplete TYPE TEXT VARNAME",
769 "Autocompletion handler (internal, for vtysh)\n"
772 "cmd_token->varname\n")
774 struct cmd_token tok
;
775 vector comps
= vector_init(32);
778 memset(&tok
, 0, sizeof(tok
));
779 tok
.type
= atoi(argv
[1]->arg
);
780 tok
.text
= argv
[2]->arg
;
781 tok
.varname
= argv
[3]->arg
;
782 if (!strcmp(tok
.varname
, "-"))
785 cmd_variable_complete(&tok
, NULL
, comps
);
787 for (i
= 0; i
< vector_active(comps
); i
++) {
788 char *text
= vector_slot(comps
, i
);
789 vty_out(vty
, "%s\n", text
);
790 XFREE(MTYPE_COMPLETION
, text
);
798 * Generate possible tab-completions for the given input. This function only
799 * returns results that would result in a valid command if used as Readline
800 * completions (as is the case in vtysh). For instance, if the passed vline ends
801 * with '4.3.2', the strings 'A.B.C.D' and 'A.B.C.D/M' will _not_ be returned.
803 * @param vline vectorized input line
805 * @param status location to store matcher status code in
806 * @return set of valid strings for use with Readline as tab-completions.
809 char **cmd_complete_command(vector vline
, struct vty
*vty
, int *status
)
812 int original_node
= vty
->node
;
813 vector input_line
= vector_init(vector_count(vline
));
815 // if the first token is 'do' we'll want to execute the command in the
817 int do_shortcut
= cmd_try_do_shortcut(vty
->node
, vector_slot(vline
, 0));
818 vty
->node
= do_shortcut
? ENABLE_NODE
: original_node
;
820 // construct the input line we'll be matching on
821 unsigned int offset
= (do_shortcut
) ? 1 : 0;
822 for (unsigned index
= 0; index
+ offset
< vector_active(vline
); index
++)
823 vector_set_index(input_line
, index
,
824 vector_lookup(vline
, index
+ offset
));
826 // get token completions -- this is a copying operation
827 vector comps
= NULL
, initial_comps
;
828 initial_comps
= cmd_complete_command_real(input_line
, vty
, status
);
830 if (!MATCHER_ERROR(*status
)) {
831 assert(initial_comps
);
832 // filter out everything that is not suitable for a
834 comps
= vector_init(VECTOR_MIN_SIZE
);
835 for (unsigned int i
= 0; i
< vector_active(initial_comps
);
837 struct cmd_token
*token
= vector_slot(initial_comps
, i
);
838 if (token
->type
== WORD_TKN
)
839 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
,
841 else if (IS_VARYING_TOKEN(token
->type
)) {
842 const char *ref
= vector_lookup(
843 vline
, vector_active(vline
) - 1);
844 cmd_variable_complete(token
, ref
, comps
);
847 vector_free(initial_comps
);
849 // since we filtered results, we need to re-set status code
850 switch (vector_active(comps
)) {
852 *status
= CMD_ERR_NO_MATCH
;
855 *status
= CMD_COMPLETE_FULL_MATCH
;
858 *status
= CMD_COMPLETE_LIST_MATCH
;
861 // copy completions text into an array of char*
862 ret
= XMALLOC(MTYPE_TMP
,
863 (vector_active(comps
) + 1) * sizeof(char *));
865 for (i
= 0; i
< vector_active(comps
); i
++) {
866 ret
[i
] = vector_slot(comps
, i
);
868 // set the last element to NULL, because this array is used in
869 // a Readline completion_generator function which expects NULL
870 // as a sentinel value
874 } else if (initial_comps
)
875 vector_free(initial_comps
);
877 // comps should always be null here
880 // free the adjusted input line
881 vector_free(input_line
);
883 // reset vty->node to its original value
884 vty
->node
= original_node
;
889 /* return parent node */
890 /* MUST eventually converge on CONFIG_NODE */
891 enum node_type
node_parent(enum node_type node
)
893 struct cmd_node
*cnode
;
895 assert(node
> CONFIG_NODE
);
897 cnode
= vector_lookup(cmdvec
, node
);
899 return cnode
->parent_node
;
902 /* Execute command by argument vline vector. */
903 static int cmd_execute_command_real(vector vline
, enum cmd_filter_type filter
,
905 const struct cmd_element
**cmd
,
906 unsigned int up_level
)
908 struct list
*argv_list
;
909 enum matcher_rv status
;
910 const struct cmd_element
*matched_element
= NULL
;
912 int xpath_index
= vty
->xpath_index
;
913 int node
= vty
->node
;
915 /* only happens for legacy split config file load; need to check for
916 * a match before calling node_exit handlers below
918 for (i
= 0; i
< up_level
; i
++) {
919 struct cmd_node
*cnode
;
921 if (node
<= CONFIG_NODE
)
922 return CMD_NO_LEVEL_UP
;
924 cnode
= vector_slot(cmdvec
, node
);
925 node
= node_parent(node
);
927 if (xpath_index
> 0 && !cnode
->no_xpath
)
931 struct graph
*cmdgraph
= cmd_node_graph(cmdvec
, node
);
932 status
= command_match(cmdgraph
, vline
, &argv_list
, &matched_element
);
935 *cmd
= matched_element
;
937 // if matcher error, return corresponding CMD_ERR
938 if (MATCHER_ERROR(status
)) {
940 list_delete(&argv_list
);
942 case MATCHER_INCOMPLETE
:
943 return CMD_ERR_INCOMPLETE
;
944 case MATCHER_AMBIGUOUS
:
945 return CMD_ERR_AMBIGUOUS
;
947 return CMD_ERR_NO_MATCH
;
951 for (i
= 0; i
< up_level
; i
++)
954 // build argv array from argv list
955 struct cmd_token
**argv
= XMALLOC(
956 MTYPE_TMP
, argv_list
->count
* sizeof(struct cmd_token
*));
958 struct cmd_token
*token
;
961 for (ALL_LIST_ELEMENTS_RO(argv_list
, ln
, token
))
964 int argc
= argv_list
->count
;
967 if (matched_element
->daemon
)
968 ret
= CMD_SUCCESS_DAEMON
;
971 /* Clear array of enqueued configuration changes. */
972 vty
->num_cfg_changes
= 0;
973 memset(&vty
->cfg_changes
, 0, sizeof(vty
->cfg_changes
));
975 /* Regenerate candidate configuration if necessary. */
976 if (frr_get_cli_mode() == FRR_CLI_CLASSIC
977 && running_config
->version
978 > vty
->candidate_config
->version
)
979 nb_config_replace(vty
->candidate_config
,
980 running_config
, true);
983 * Perform pending commit (if any) before executing
986 if (matched_element
->attr
!= CMD_ATTR_YANG
)
987 (void)nb_cli_pending_commit_check(vty
);
990 ret
= matched_element
->func(matched_element
, vty
, argc
, argv
);
993 // delete list and cmd_token's in it
994 list_delete(&argv_list
);
995 XFREE(MTYPE_TMP
, argv
);
1001 * Execute a given command, handling things like "do ..." and checking
1002 * whether the given command might apply at a parent node if doesn't
1003 * apply for the current node.
1005 * @param vline Command line input, vector of char* where each element is
1007 * @param vty The vty context in which the command should be executed.
1008 * @param cmd Pointer where the struct cmd_element of the matched command
1009 * will be stored, if any. May be set to NULL if this info is
1011 * @param vtysh If set != 0, don't lookup the command at parent nodes.
1012 * @return The status of the command that has been executed or an error code
1013 * as to why no command could be executed.
1015 int cmd_execute_command(vector vline
, struct vty
*vty
,
1016 const struct cmd_element
**cmd
, int vtysh
)
1018 int ret
, saved_ret
= 0;
1019 enum node_type onode
, try_node
;
1020 int orig_xpath_index
;
1022 onode
= try_node
= vty
->node
;
1023 orig_xpath_index
= vty
->xpath_index
;
1025 if (cmd_try_do_shortcut(vty
->node
, vector_slot(vline
, 0))) {
1026 vector shifted_vline
;
1029 vty
->node
= ENABLE_NODE
;
1030 vty
->xpath_index
= 0;
1031 /* We can try it on enable node, cos' the vty is authenticated
1034 shifted_vline
= vector_init(vector_count(vline
));
1036 for (index
= 1; index
< vector_active(vline
); index
++)
1037 vector_set_index(shifted_vline
, index
- 1,
1038 vector_lookup(vline
, index
));
1040 ret
= cmd_execute_command_real(shifted_vline
, FILTER_RELAXED
,
1043 vector_free(shifted_vline
);
1045 vty
->xpath_index
= orig_xpath_index
;
1050 cmd_execute_command_real(vline
, FILTER_RELAXED
, vty
, cmd
, 0);
1055 if (ret
!= CMD_SUCCESS
&& ret
!= CMD_WARNING
1056 && ret
!= CMD_ERR_AMBIGUOUS
&& ret
!= CMD_ERR_INCOMPLETE
1057 && ret
!= CMD_NOT_MY_INSTANCE
&& ret
!= CMD_WARNING_CONFIG_FAILED
) {
1058 /* This assumes all nodes above CONFIG_NODE are childs of
1060 while (vty
->node
> CONFIG_NODE
) {
1061 struct cmd_node
*cnode
= vector_slot(cmdvec
, try_node
);
1063 try_node
= node_parent(try_node
);
1064 vty
->node
= try_node
;
1065 if (vty
->xpath_index
> 0 && !cnode
->no_xpath
)
1068 ret
= cmd_execute_command_real(vline
, FILTER_RELAXED
,
1070 if (ret
== CMD_SUCCESS
|| ret
== CMD_WARNING
1071 || ret
== CMD_ERR_AMBIGUOUS
|| ret
== CMD_ERR_INCOMPLETE
1072 || ret
== CMD_NOT_MY_INSTANCE
1073 || ret
== CMD_WARNING_CONFIG_FAILED
)
1076 /* no command succeeded, reset the vty to the original node */
1078 vty
->xpath_index
= orig_xpath_index
;
1081 /* return command status for original node */
1086 * Execute a given command, matching it strictly against the current node.
1087 * This mode is used when reading config files.
1089 * @param vline Command line input, vector of char* where each element is
1091 * @param vty The vty context in which the command should be executed.
1092 * @param cmd Pointer where the struct cmd_element* of the matched command
1093 * will be stored, if any. May be set to NULL if this info is
1095 * @return The status of the command that has been executed or an error code
1096 * as to why no command could be executed.
1098 int cmd_execute_command_strict(vector vline
, struct vty
*vty
,
1099 const struct cmd_element
**cmd
)
1101 return cmd_execute_command_real(vline
, FILTER_STRICT
, vty
, cmd
, 0);
1105 * Hook for preprocessing command string before executing.
1107 * All subscribers are called with the raw command string that is to be
1108 * executed. If any changes are to be made, a new string should be allocated
1109 * with MTYPE_TMP and *cmd_out updated to point to this new string. The caller
1110 * is then responsible for freeing this string.
1112 * All processing functions must be mutually exclusive in their action, i.e. if
1113 * one subscriber decides to modify the command, all others must not modify it
1114 * when called. Feeding the output of one processing command into a subsequent
1115 * one is not supported.
1117 * This hook is intentionally internal to the command processing system.
1120 * The raw command string.
1123 * The result of any processing.
1125 DECLARE_HOOK(cmd_execute
,
1126 (struct vty
*vty
, const char *cmd_in
, char **cmd_out
),
1127 (vty
, cmd_in
, cmd_out
));
1128 DEFINE_HOOK(cmd_execute
, (struct vty
*vty
, const char *cmd_in
, char **cmd_out
),
1129 (vty
, cmd_in
, cmd_out
));
1131 /* Hook executed after a CLI command. */
1132 DECLARE_KOOH(cmd_execute_done
, (struct vty
*vty
, const char *cmd_exec
),
1134 DEFINE_KOOH(cmd_execute_done
, (struct vty
*vty
, const char *cmd_exec
),
1138 * cmd_execute hook subscriber to handle `|` actions.
1140 static int handle_pipe_action(struct vty
*vty
, const char *cmd_in
,
1144 char *orig
, *working
, *token
, *u
;
1145 char *pipe
= strstr(cmd_in
, "| ");
1151 /* duplicate string for processing purposes, not including pipe */
1152 orig
= working
= XSTRDUP(MTYPE_TMP
, pipe
+ 2);
1154 /* retrieve action */
1155 token
= strsep(&working
, " ");
1158 /* match result to known actions */
1159 if (strmatch(token
, "include")) {
1160 /* the remaining text should be a regexp */
1161 char *regexp
= working
;
1164 vty_out(vty
, "%% Need a regexp to filter with\n");
1169 bool succ
= vty_set_include(vty
, regexp
);
1172 vty_out(vty
, "%% Bad regexp '%s'\n", regexp
);
1176 *cmd_out
= XSTRDUP(MTYPE_TMP
, cmd_in
);
1180 vty_out(vty
, "%% Unknown action '%s'\n", token
);
1186 XFREE(MTYPE_TMP
, orig
);
1190 static int handle_pipe_action_done(struct vty
*vty
, const char *cmd_exec
)
1193 vty_set_include(vty
, NULL
);
1198 int cmd_execute(struct vty
*vty
, const char *cmd
,
1199 const struct cmd_element
**matched
, int vtysh
)
1202 char *cmd_out
= NULL
;
1203 const char *cmd_exec
= NULL
;
1206 ret
= hook_call(cmd_execute
, vty
, cmd
, &cmd_out
);
1212 cmd_exec
= cmd_out
? (const char *)cmd_out
: cmd
;
1214 vline
= cmd_make_strvec(cmd_exec
);
1217 ret
= cmd_execute_command(vline
, vty
, matched
, vtysh
);
1218 cmd_free_strvec(vline
);
1224 hook_call(cmd_execute_done
, vty
, cmd_exec
);
1226 XFREE(MTYPE_TMP
, cmd_out
);
1233 * Parse one line of config, walking up the parse tree attempting to find a
1236 * @param vty The vty context in which the command should be executed.
1237 * @param cmd Pointer where the struct cmd_element* of the match command
1238 * will be stored, if any. May be set to NULL if this info is
1240 * @param use_daemon Boolean to control whether or not we match on
1241 * CMD_SUCCESS_DAEMON
1243 * @return The status of the command that has been executed or an error code
1244 * as to why no command could be executed.
1246 int command_config_read_one_line(struct vty
*vty
,
1247 const struct cmd_element
**cmd
,
1248 uint32_t line_num
, int use_daemon
)
1252 unsigned up_level
= 0;
1254 vline
= cmd_make_strvec(vty
->buf
);
1256 /* In case of comment line */
1260 /* Execute configuration command : this is strict match */
1261 ret
= cmd_execute_command_strict(vline
, vty
, cmd
);
1263 /* The logic for trying parent nodes is in cmd_execute_command_real()
1264 * since calling ->node_exit() correctly is a bit involved. This is
1265 * also the only reason CMD_NO_LEVEL_UP exists.
1267 while (!(use_daemon
&& ret
== CMD_SUCCESS_DAEMON
)
1268 && !(!use_daemon
&& ret
== CMD_ERR_NOTHING_TODO
)
1269 && ret
!= CMD_SUCCESS
&& ret
!= CMD_WARNING
1270 && ret
!= CMD_ERR_AMBIGUOUS
&& ret
!= CMD_ERR_INCOMPLETE
1271 && ret
!= CMD_NOT_MY_INSTANCE
&& ret
!= CMD_WARNING_CONFIG_FAILED
1272 && ret
!= CMD_NO_LEVEL_UP
)
1273 ret
= cmd_execute_command_real(vline
, FILTER_STRICT
, vty
, cmd
,
1276 if (ret
== CMD_NO_LEVEL_UP
)
1277 ret
= CMD_ERR_NO_MATCH
;
1279 if (ret
!= CMD_SUCCESS
&&
1280 ret
!= CMD_WARNING
&&
1281 ret
!= CMD_SUCCESS_DAEMON
) {
1282 struct vty_error
*ve
= XCALLOC(MTYPE_TMP
, sizeof(*ve
));
1284 memcpy(ve
->error_buf
, vty
->buf
, VTY_BUFSIZ
);
1285 ve
->line_num
= line_num
;
1287 vty
->error
= list_new();
1289 listnode_add(vty
->error
, ve
);
1292 cmd_free_strvec(vline
);
1297 /* Configuration make from file. */
1298 int config_from_file(struct vty
*vty
, FILE *fp
, unsigned int *line_num
)
1300 int ret
, error_ret
= 0;
1303 while (fgets(vty
->buf
, VTY_BUFSIZ
, fp
)) {
1306 ret
= command_config_read_one_line(vty
, NULL
, *line_num
, 0);
1308 if (ret
!= CMD_SUCCESS
&& ret
!= CMD_WARNING
1309 && ret
!= CMD_ERR_NOTHING_TODO
)
1320 /* Configuration from terminal */
1321 DEFUN (config_terminal
,
1322 config_terminal_cmd
,
1323 "configure [terminal]",
1324 "Configuration from vty interface\n"
1325 "Configuration terminal\n")
1327 return vty_config_enter(vty
, false, false);
1330 /* Enable command */
1334 "Turn on privileged mode command\n")
1336 /* If enable password is NULL, change to ENABLE_NODE */
1337 if ((host
.enable
== NULL
&& host
.enable_encrypt
== NULL
)
1338 || vty
->type
== VTY_SHELL_SERV
)
1339 vty
->node
= ENABLE_NODE
;
1341 vty
->node
= AUTH_ENABLE_NODE
;
1346 /* Disable command */
1350 "Turn off privileged mode command\n")
1352 if (vty
->node
== ENABLE_NODE
)
1353 vty
->node
= VIEW_NODE
;
1357 /* Down vty node level. */
1361 "Exit current mode and down to previous mode\n")
1367 static int root_on_exit(struct vty
*vty
)
1372 vty
->status
= VTY_CLOSE
;
1376 void cmd_exit(struct vty
*vty
)
1378 struct cmd_node
*cnode
= vector_lookup(cmdvec
, vty
->node
);
1380 if (cnode
->node_exit
) {
1381 if (!cnode
->node_exit(vty
))
1384 if (cnode
->parent_node
)
1385 vty
->node
= cnode
->parent_node
;
1386 if (vty
->xpath_index
> 0 && !cnode
->no_xpath
)
1394 "Exit current mode and down to previous mode\n")
1396 return config_exit(self
, vty
, argc
, argv
);
1400 /* End of configuration. */
1404 "End current mode and change to enable mode.\n")
1407 vty_config_exit(vty
);
1408 vty
->node
= ENABLE_NODE
;
1414 DEFUN (show_version
,
1418 "Displays zebra version\n")
1420 vty_out(vty
, "%s %s (%s) on %s(%s).\n", FRR_FULL_NAME
, FRR_VERSION
,
1421 cmd_hostname_get() ? cmd_hostname_get() : "", cmd_system_get(),
1423 vty_out(vty
, "%s%s\n", FRR_COPYRIGHT
, GIT_INFO
);
1424 #ifdef ENABLE_VERSION_BUILD_CONFIG
1425 vty_out(vty
, "configured with:\n %s\n", FRR_CONFIG_ARGS
);
1430 /* Help display function for all node. */
1434 "Description of the interactive help system\n")
1437 "Quagga VTY provides advanced help feature. When you need help,\n\
1438 anytime at the command line please press '?'.\n\
1440 If nothing matches, the help list will be empty and you must backup\n\
1441 until entering a '?' shows the available options.\n\
1442 Two styles of help are provided:\n\
1443 1. Full help is available when you are ready to enter a\n\
1444 command argument (e.g. 'show ?') and describes each possible\n\
1446 2. Partial help is provided when an abbreviated argument is entered\n\
1447 and you want to know what arguments match the input\n\
1448 (e.g. 'show me?'.)\n\n");
1452 static void permute(struct graph_node
*start
, struct vty
*vty
)
1454 static struct list
*position
= NULL
;
1456 position
= list_new();
1458 struct cmd_token
*stok
= start
->data
;
1459 struct graph_node
*gnn
;
1460 struct listnode
*ln
;
1463 listnode_add(position
, start
);
1464 for (unsigned int i
= 0; i
< vector_active(start
->to
); i
++) {
1465 struct graph_node
*gn
= vector_slot(start
->to
, i
);
1466 struct cmd_token
*tok
= gn
->data
;
1467 if (tok
->attr
== CMD_ATTR_HIDDEN
1468 || tok
->attr
== CMD_ATTR_DEPRECATED
)
1470 else if (tok
->type
== END_TKN
|| gn
== start
) {
1472 for (ALL_LIST_ELEMENTS_RO(position
, ln
, gnn
)) {
1473 struct cmd_token
*tt
= gnn
->data
;
1474 if (tt
->type
< SPECIAL_TKN
)
1475 vty_out(vty
, " %s", tt
->text
);
1478 vty_out(vty
, "...");
1482 if (stok
->type
== FORK_TKN
&& tok
->type
!= FORK_TKN
)
1483 for (ALL_LIST_ELEMENTS_RO(position
, ln
, gnn
))
1492 list_delete_node(position
, listtail(position
));
1495 static void print_cmd(struct vty
*vty
, const char *cmd
)
1497 int i
, j
, len
= strlen(cmd
);
1502 for (i
= 0; i
< len
; i
++) {
1506 else if (strchr(" ()<>[]{}|", cmd
[i
]))
1512 if (isspace(cmd
[i
])) {
1513 /* skip leading whitespace */
1516 /* skip trailing whitespace */
1519 /* skip all whitespace after opening brackets or pipe */
1520 if (strchr("(<[{|", cmd
[i
- 1])) {
1521 while (isspace(cmd
[i
+ 1]))
1525 /* skip repeated whitespace */
1526 if (isspace(cmd
[i
+ 1]))
1528 /* skip whitespace before closing brackets or pipe */
1529 if (strchr(")>]}|", cmd
[i
+ 1]))
1531 /* convert tabs to spaces */
1532 if (cmd
[i
] == '\t') {
1542 vty_out(vty
, "%s\n", buf
);
1545 int cmd_list_cmds(struct vty
*vty
, int do_permute
)
1547 struct cmd_node
*node
= vector_slot(cmdvec
, vty
->node
);
1550 cmd_finalize_node(node
);
1551 permute(vector_slot(node
->cmdgraph
->nodes
, 0), vty
);
1553 /* loop over all commands at this node */
1554 const struct cmd_element
*element
= NULL
;
1555 for (unsigned int i
= 0; i
< vector_active(node
->cmd_vector
);
1557 if ((element
= vector_slot(node
->cmd_vector
, i
))
1558 && element
->attr
!= CMD_ATTR_DEPRECATED
1559 && element
->attr
!= CMD_ATTR_HIDDEN
) {
1561 print_cmd(vty
, element
->string
);
1567 /* Help display function for all node. */
1570 "list [permutations]",
1571 "Print command list\n"
1572 "Print all possible command permutations\n")
1574 return cmd_list_cmds(vty
, argc
== 2);
1577 DEFUN (show_commandtree
,
1578 show_commandtree_cmd
,
1579 "show commandtree [permutations]",
1581 "Show command tree\n"
1582 "Permutations that we are interested in\n")
1584 return cmd_list_cmds(vty
, argc
== 3);
1587 DEFUN_HIDDEN(show_cli_graph
,
1592 "Dump current command space as DOT graph\n")
1594 struct cmd_node
*cn
= vector_slot(cmdvec
, vty
->node
);
1597 cmd_finalize_node(cn
);
1598 dot
= cmd_graph_dump_dot(cn
->cmdgraph
);
1600 vty_out(vty
, "%s\n", dot
);
1601 XFREE(MTYPE_TMP
, dot
);
1605 static int vty_write_config(struct vty
*vty
)
1608 struct cmd_node
*node
;
1613 nb_cli_show_config_prepare(running_config
, false);
1615 if (vty
->type
== VTY_TERM
) {
1616 vty_out(vty
, "\nCurrent configuration:\n");
1617 vty_out(vty
, "!\n");
1620 if (strcmp(frr_defaults_version(), FRR_VER_SHORT
))
1621 vty_out(vty
, "! loaded from %s\n", frr_defaults_version());
1622 vty_out(vty
, "frr version %s\n", FRR_VER_SHORT
);
1623 vty_out(vty
, "frr defaults %s\n", frr_defaults_profile());
1624 vty_out(vty
, "!\n");
1626 for (i
= 0; i
< vector_active(cmdvec
); i
++)
1627 if ((node
= vector_slot(cmdvec
, i
)) && node
->config_write
) {
1628 if ((*node
->config_write
)(vty
))
1629 vty_out(vty
, "!\n");
1632 if (vty
->type
== VTY_TERM
) {
1633 vty_out(vty
, "end\n");
1639 static int file_write_config(struct vty
*vty
)
1642 char *config_file
, *slash
;
1643 char *config_file_tmp
= NULL
;
1644 char *config_file_sav
= NULL
;
1645 int ret
= CMD_WARNING
;
1646 struct vty
*file_vty
;
1647 struct stat conf_stat
;
1652 /* Check and see if we are operating under vtysh configuration */
1653 if (host
.config
== NULL
) {
1655 "Can't save to configuration file, using vtysh.\n");
1660 config_file
= host
.config
;
1663 #define O_DIRECTORY 0
1665 slash
= strrchr(config_file
, '/');
1667 char *config_dir
= XSTRDUP(MTYPE_TMP
, config_file
);
1668 config_dir
[slash
- config_file
] = '\0';
1669 dirfd
= open(config_dir
, O_DIRECTORY
| O_RDONLY
);
1670 XFREE(MTYPE_TMP
, config_dir
);
1672 dirfd
= open(".", O_DIRECTORY
| O_RDONLY
);
1673 /* if dirfd is invalid, directory sync fails, but we're still OK */
1675 size_t config_file_sav_sz
= strlen(config_file
) + strlen(CONF_BACKUP_EXT
) + 1;
1676 config_file_sav
= XMALLOC(MTYPE_TMP
, config_file_sav_sz
);
1677 strlcpy(config_file_sav
, config_file
, config_file_sav_sz
);
1678 strlcat(config_file_sav
, CONF_BACKUP_EXT
, config_file_sav_sz
);
1681 config_file_tmp
= XMALLOC(MTYPE_TMP
, strlen(config_file
) + 8);
1682 snprintf(config_file_tmp
, strlen(config_file
) + 8, "%s.XXXXXX",
1685 /* Open file to configuration write. */
1686 fd
= mkstemp(config_file_tmp
);
1688 vty_out(vty
, "Can't open configuration file %s.\n",
1692 if (fchmod(fd
, CONFIGFILE_MASK
) != 0) {
1693 vty_out(vty
, "Can't chmod configuration file %s: %s (%d).\n",
1694 config_file_tmp
, safe_strerror(errno
), errno
);
1698 /* Make vty for configuration file. */
1699 file_vty
= vty_new();
1701 file_vty
->type
= VTY_FILE
;
1703 /* Config file header print. */
1704 vty_out(file_vty
, "!\n! Zebra configuration saved from vty\n! ");
1705 vty_time_print(file_vty
, 1);
1706 vty_out(file_vty
, "!\n");
1707 vty_write_config(file_vty
);
1708 vty_close(file_vty
);
1710 if (stat(config_file
, &conf_stat
) >= 0) {
1711 if (unlink(config_file_sav
) != 0)
1712 if (errno
!= ENOENT
) {
1714 "Can't unlink backup configuration file %s.\n",
1718 if (link(config_file
, config_file_sav
) != 0) {
1720 "Can't backup old configuration file %s.\n",
1727 if (rename(config_file_tmp
, config_file
) != 0) {
1728 vty_out(vty
, "Can't save configuration file %s.\n",
1735 vty_out(vty
, "Configuration saved to %s\n", config_file
);
1739 if (ret
!= CMD_SUCCESS
)
1740 unlink(config_file_tmp
);
1743 XFREE(MTYPE_TMP
, config_file_tmp
);
1744 XFREE(MTYPE_TMP
, config_file_sav
);
1748 /* Write current configuration into file. */
1750 DEFUN (config_write
,
1752 "write [<file|memory|terminal>]",
1753 "Write running configuration to memory, network, or terminal\n"
1754 "Write to configuration file\n"
1755 "Write configuration currently in memory\n"
1756 "Write configuration to terminal\n")
1758 const int idx_type
= 1;
1760 // if command was 'write terminal' or 'write memory'
1761 if (argc
== 2 && (!strcmp(argv
[idx_type
]->text
, "terminal"))) {
1762 return vty_write_config(vty
);
1765 return file_write_config(vty
);
1768 /* ALIAS_FIXME for 'write <terminal|memory>' */
1769 DEFUN (show_running_config
,
1770 show_running_config_cmd
,
1771 "show running-config",
1773 "running configuration (same as write terminal)\n")
1775 return vty_write_config(vty
);
1778 /* ALIAS_FIXME for 'write file' */
1779 DEFUN (copy_runningconf_startupconf
,
1780 copy_runningconf_startupconf_cmd
,
1781 "copy running-config startup-config",
1782 "Copy configuration\n"
1783 "Copy running config to... \n"
1784 "Copy running config to startup config (same as write file/memory)\n")
1786 return file_write_config(vty
);
1790 /* Write startup configuration into the terminal. */
1791 DEFUN (show_startup_config
,
1792 show_startup_config_cmd
,
1793 "show startup-config",
1795 "Contents of startup configuration\n")
1802 if (host
.config
== NULL
)
1805 confp
= fopen(host
.config
, "r");
1806 if (confp
== NULL
) {
1807 vty_out(vty
, "Can't open configuration file [%s] due to '%s'\n",
1808 host
.config
, safe_strerror(errno
));
1812 while (fgets(buf
, BUFSIZ
, confp
)) {
1815 while (*cp
!= '\r' && *cp
!= '\n' && *cp
!= '\0')
1819 vty_out(vty
, "%s\n", buf
);
1827 int cmd_domainname_set(const char *domainname
)
1829 XFREE(MTYPE_HOST
, host
.domainname
);
1830 host
.domainname
= domainname
? XSTRDUP(MTYPE_HOST
, domainname
) : NULL
;
1834 /* Hostname configuration */
1835 DEFUN(config_domainname
,
1838 "Set system's domain name\n"
1839 "This system's domain name\n")
1841 struct cmd_token
*word
= argv
[1];
1843 if (!isalpha((unsigned char)word
->arg
[0])) {
1844 vty_out(vty
, "Please specify string starting with alphabet\n");
1845 return CMD_WARNING_CONFIG_FAILED
;
1848 return cmd_domainname_set(word
->arg
);
1851 DEFUN(config_no_domainname
,
1853 "no domainname [DOMAINNAME]",
1855 "Reset system's domain name\n"
1856 "domain name of this router\n")
1858 return cmd_domainname_set(NULL
);
1861 int cmd_hostname_set(const char *hostname
)
1863 XFREE(MTYPE_HOST
, host
.name
);
1864 host
.name
= hostname
? XSTRDUP(MTYPE_HOST
, hostname
) : NULL
;
1868 /* Hostname configuration */
1869 DEFUN (config_hostname
,
1872 "Set system's network name\n"
1873 "This system's network name\n")
1875 struct cmd_token
*word
= argv
[1];
1877 if (!isalnum((unsigned char)word
->arg
[0])) {
1879 "Please specify string starting with alphabet or number\n");
1880 return CMD_WARNING_CONFIG_FAILED
;
1883 /* With reference to RFC 1123 Section 2.1 */
1884 if (strlen(word
->arg
) > HOSTNAME_LEN
) {
1885 vty_out(vty
, "Hostname length should be less than %d chars\n",
1887 return CMD_WARNING_CONFIG_FAILED
;
1890 return cmd_hostname_set(word
->arg
);
1893 DEFUN (config_no_hostname
,
1895 "no hostname [HOSTNAME]",
1897 "Reset system's network name\n"
1898 "Host name of this router\n")
1900 return cmd_hostname_set(NULL
);
1903 /* VTY interface password set. */
1904 DEFUN (config_password
,
1906 "password [(8-8)] WORD",
1907 "Modify the terminal connection password\n"
1908 "Specifies a HIDDEN password will follow\n"
1909 "The password string\n")
1913 if (argc
== 3) // '8' was specified
1916 XFREE(MTYPE_HOST
, host
.password
);
1917 host
.password
= NULL
;
1918 if (host
.password_encrypt
)
1919 XFREE(MTYPE_HOST
, host
.password_encrypt
);
1920 host
.password_encrypt
=
1921 XSTRDUP(MTYPE_HOST
, argv
[idx_word
]->arg
);
1925 if (!isalnum((unsigned char)argv
[idx_8
]->arg
[0])) {
1927 "Please specify string starting with alphanumeric\n");
1928 return CMD_WARNING_CONFIG_FAILED
;
1932 XFREE(MTYPE_HOST
, host
.password
);
1933 host
.password
= NULL
;
1936 if (host
.password_encrypt
)
1937 XFREE(MTYPE_HOST
, host
.password_encrypt
);
1938 host
.password_encrypt
=
1939 XSTRDUP(MTYPE_HOST
, zencrypt(argv
[idx_8
]->arg
));
1941 host
.password
= XSTRDUP(MTYPE_HOST
, argv
[idx_8
]->arg
);
1946 /* VTY interface password delete. */
1947 DEFUN (no_config_password
,
1951 "Modify the terminal connection password\n")
1953 bool warned
= false;
1955 if (host
.password
) {
1956 if (!vty_shell_serv(vty
)) {
1957 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
1960 XFREE(MTYPE_HOST
, host
.password
);
1962 host
.password
= NULL
;
1964 if (host
.password_encrypt
) {
1965 if (!warned
&& !vty_shell_serv(vty
))
1966 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
1967 XFREE(MTYPE_HOST
, host
.password_encrypt
);
1969 host
.password_encrypt
= NULL
;
1974 /* VTY enable password set. */
1975 DEFUN (config_enable_password
,
1976 enable_password_cmd
,
1977 "enable password [(8-8)] WORD",
1978 "Modify enable password parameters\n"
1979 "Assign the privileged level password\n"
1980 "Specifies a HIDDEN password will follow\n"
1981 "The HIDDEN 'enable' password string\n")
1986 /* Crypt type is specified. */
1988 if (argv
[idx_8
]->arg
[0] == '8') {
1990 XFREE(MTYPE_HOST
, host
.enable
);
1993 if (host
.enable_encrypt
)
1994 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
1995 host
.enable_encrypt
=
1996 XSTRDUP(MTYPE_HOST
, argv
[idx_word
]->arg
);
2000 vty_out(vty
, "Unknown encryption type.\n");
2001 return CMD_WARNING_CONFIG_FAILED
;
2005 if (!isalnum((unsigned char)argv
[idx_8
]->arg
[0])) {
2007 "Please specify string starting with alphanumeric\n");
2008 return CMD_WARNING_CONFIG_FAILED
;
2012 XFREE(MTYPE_HOST
, host
.enable
);
2015 /* Plain password input. */
2017 if (host
.enable_encrypt
)
2018 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2019 host
.enable_encrypt
=
2020 XSTRDUP(MTYPE_HOST
, zencrypt(argv
[idx_8
]->arg
));
2022 host
.enable
= XSTRDUP(MTYPE_HOST
, argv
[idx_8
]->arg
);
2027 /* VTY enable password delete. */
2028 DEFUN (no_config_enable_password
,
2029 no_enable_password_cmd
,
2030 "no enable password",
2032 "Modify enable password parameters\n"
2033 "Assign the privileged level password\n")
2035 bool warned
= false;
2038 if (!vty_shell_serv(vty
)) {
2039 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
2042 XFREE(MTYPE_HOST
, host
.enable
);
2046 if (host
.enable_encrypt
) {
2047 if (!warned
&& !vty_shell_serv(vty
))
2048 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
2049 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2051 host
.enable_encrypt
= NULL
;
2056 DEFUN (service_password_encrypt
,
2057 service_password_encrypt_cmd
,
2058 "service password-encryption",
2059 "Set up miscellaneous service\n"
2060 "Enable encrypted passwords\n")
2067 if (host
.password
) {
2068 if (host
.password_encrypt
)
2069 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2070 host
.password_encrypt
=
2071 XSTRDUP(MTYPE_HOST
, zencrypt(host
.password
));
2074 if (host
.enable_encrypt
)
2075 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2076 host
.enable_encrypt
=
2077 XSTRDUP(MTYPE_HOST
, zencrypt(host
.enable
));
2083 DEFUN (no_service_password_encrypt
,
2084 no_service_password_encrypt_cmd
,
2085 "no service password-encryption",
2087 "Set up miscellaneous service\n"
2088 "Enable encrypted passwords\n")
2095 if (host
.password_encrypt
)
2096 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2097 host
.password_encrypt
= NULL
;
2099 if (host
.enable_encrypt
)
2100 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2101 host
.enable_encrypt
= NULL
;
2106 DEFUN (config_terminal_length
,
2107 config_terminal_length_cmd
,
2108 "terminal length (0-512)",
2109 "Set terminal line parameters\n"
2110 "Set number of lines on a screen\n"
2111 "Number of lines on screen (0 for no pausing)\n")
2115 vty
->lines
= atoi(argv
[idx_number
]->arg
);
2120 DEFUN (config_terminal_no_length
,
2121 config_terminal_no_length_cmd
,
2122 "terminal no length",
2123 "Set terminal line parameters\n"
2125 "Set number of lines on a screen\n")
2131 DEFUN (service_terminal_length
,
2132 service_terminal_length_cmd
,
2133 "service terminal-length (0-512)",
2134 "Set up miscellaneous service\n"
2135 "System wide terminal length configuration\n"
2136 "Number of lines of VTY (0 means no line control)\n")
2140 host
.lines
= atoi(argv
[idx_number
]->arg
);
2145 DEFUN (no_service_terminal_length
,
2146 no_service_terminal_length_cmd
,
2147 "no service terminal-length [(0-512)]",
2149 "Set up miscellaneous service\n"
2150 "System wide terminal length configuration\n"
2151 "Number of lines of VTY (0 means no line control)\n")
2157 DEFUN_HIDDEN (do_echo
,
2160 "Echo a message back to the vty\n"
2161 "The message to echo\n")
2165 vty_out(vty
, "%s\n",
2166 ((message
= argv_concat(argv
, argc
, 1)) ? message
: ""));
2168 XFREE(MTYPE_TMP
, message
);
2172 DEFUN (config_logmsg
,
2174 "logmsg <emergencies|alerts|critical|errors|warnings|notifications|informational|debugging> MESSAGE...",
2175 "Send a message to enabled logging destinations\n"
2177 "The message to send\n")
2179 int idx_log_level
= 1;
2180 int idx_message
= 2;
2184 level
= log_level_match(argv
[idx_log_level
]->arg
);
2185 if (level
== ZLOG_DISABLED
)
2186 return CMD_ERR_NO_MATCH
;
2189 ((message
= argv_concat(argv
, argc
, idx_message
)) ? message
: ""));
2191 XFREE(MTYPE_TMP
, message
);
2196 DEFUN (debug_memstats
,
2198 "[no] debug memstats-at-exit",
2201 "Print memory type statistics at exit\n")
2203 debug_memstats_at_exit
= !!strcmp(argv
[0]->text
, "no");
2207 int cmd_banner_motd_file(const char *file
)
2209 int success
= CMD_SUCCESS
;
2214 rpath
= realpath(file
, p
);
2216 return CMD_ERR_NO_FILE
;
2217 in
= strstr(rpath
, SYSCONFDIR
);
2219 XFREE(MTYPE_HOST
, host
.motdfile
);
2220 host
.motdfile
= XSTRDUP(MTYPE_HOST
, file
);
2222 success
= CMD_WARNING_CONFIG_FAILED
;
2227 void cmd_banner_motd_line(const char *line
)
2229 XFREE(MTYPE_HOST
, host
.motd
);
2230 host
.motd
= XSTRDUP(MTYPE_HOST
, line
);
2233 DEFUN (banner_motd_file
,
2234 banner_motd_file_cmd
,
2235 "banner motd file FILE",
2238 "Banner from a file\n"
2242 const char *filename
= argv
[idx_file
]->arg
;
2243 int cmd
= cmd_banner_motd_file(filename
);
2245 if (cmd
== CMD_ERR_NO_FILE
)
2246 vty_out(vty
, "%s does not exist\n", filename
);
2247 else if (cmd
== CMD_WARNING_CONFIG_FAILED
)
2248 vty_out(vty
, "%s must be in %s\n", filename
, SYSCONFDIR
);
2253 DEFUN (banner_motd_line
,
2254 banner_motd_line_cmd
,
2255 "banner motd line LINE...",
2258 "Banner from an input\n"
2264 argv_find(argv
, argc
, "LINE", &idx
);
2265 motd
= argv_concat(argv
, argc
, idx
);
2267 cmd_banner_motd_line(motd
);
2268 XFREE(MTYPE_TMP
, motd
);
2273 DEFUN (banner_motd_default
,
2274 banner_motd_default_cmd
,
2275 "banner motd default",
2276 "Set banner string\n"
2277 "Strings for motd\n"
2280 cmd_banner_motd_line(FRR_DEFAULT_MOTD
);
2284 DEFUN (no_banner_motd
,
2288 "Set banner string\n"
2289 "Strings for motd\n")
2293 XFREE(MTYPE_HOST
, host
.motdfile
);
2294 host
.motdfile
= NULL
;
2298 int cmd_find_cmds(struct vty
*vty
, struct cmd_token
**argv
, int argc
)
2300 const struct cmd_node
*node
;
2301 const struct cmd_element
*cli
;
2306 char *pattern
= argv_concat(argv
, argc
, 1);
2307 int cr
= regcomp(&exp
, pattern
, REG_NOSUB
| REG_EXTENDED
);
2308 XFREE(MTYPE_TMP
, pattern
);
2313 vty_out(vty
, "%% Invalid {...} expression\n");
2316 vty_out(vty
, "%% Bad repetition operator\n");
2319 vty_out(vty
, "%% Regex syntax error\n");
2322 vty_out(vty
, "%% Invalid collating element\n");
2325 vty_out(vty
, "%% Invalid character class name\n");
2329 "%% Regex ended with escape character (\\)\n");
2333 "%% Invalid number in \\digit construction\n");
2336 vty_out(vty
, "%% Unbalanced square brackets\n");
2339 vty_out(vty
, "%% Unbalanced parentheses\n");
2342 vty_out(vty
, "%% Unbalanced braces\n");
2346 "%% Invalid endpoint in range expression\n");
2349 vty_out(vty
, "%% Failed to compile (out of memory)\n");
2357 for (unsigned int i
= 0; i
< vector_active(cmdvec
); i
++) {
2358 node
= vector_slot(cmdvec
, i
);
2361 clis
= node
->cmd_vector
;
2362 for (unsigned int j
= 0; j
< vector_active(clis
); j
++) {
2363 cli
= vector_slot(clis
, j
);
2365 if (regexec(&exp
, cli
->string
, 0, NULL
, 0) == 0) {
2366 vty_out(vty
, " (%s) ", node
->name
);
2367 print_cmd(vty
, cli
->string
);
2380 "Find CLI command matching a regular expression\n"
2381 "Search pattern (POSIX regex)\n")
2383 return cmd_find_cmds(vty
, argv
, argc
);
2386 #if defined(DEV_BUILD) && defined(HAVE_SCRIPTING)
2387 DEFUN(script
, script_cmd
, "script SCRIPT FUNCTION",
2388 "Test command - execute a function in a script\n"
2389 "Script name (same as filename in /etc/frr/scripts/)\n"
2390 "Function name (in the script)\n")
2394 (void)str2prefix("1.2.3.4/24", &p
);
2395 struct frrscript
*fs
= frrscript_new(argv
[1]->arg
);
2397 if (frrscript_load(fs
, argv
[2]->arg
, NULL
)) {
2399 "/etc/frr/scripts/%s.lua or function '%s' not found\n",
2400 argv
[1]->arg
, argv
[2]->arg
);
2403 int ret
= frrscript_call(fs
, argv
[2]->arg
, ("p", &p
));
2405 prefix2str(&p
, buf
, sizeof(buf
));
2406 vty_out(vty
, "p: %s\n", buf
);
2407 vty_out(vty
, "Script result: %d\n", ret
);
2409 frrscript_delete(fs
);
2415 /* Set config filename. Called from vty.c */
2416 void host_config_set(const char *filename
)
2418 XFREE(MTYPE_HOST
, host
.config
);
2419 host
.config
= XSTRDUP(MTYPE_HOST
, filename
);
2422 const char *host_config_get(void)
2427 void install_default(enum node_type node
)
2429 _install_element(node
, &config_exit_cmd
);
2430 _install_element(node
, &config_quit_cmd
);
2431 _install_element(node
, &config_end_cmd
);
2432 _install_element(node
, &config_help_cmd
);
2433 _install_element(node
, &config_list_cmd
);
2434 _install_element(node
, &show_cli_graph_cmd
);
2435 _install_element(node
, &find_cmd
);
2437 _install_element(node
, &config_write_cmd
);
2438 _install_element(node
, &show_running_config_cmd
);
2440 _install_element(node
, &autocomplete_cmd
);
2442 nb_cli_install_default(node
);
2445 /* Initialize command interface. Install basic nodes and commands.
2447 * terminal = 0 -- vtysh / no logging, no config control
2448 * terminal = 1 -- normal daemon
2449 * terminal = -1 -- watchfrr / no logging, but minimal config control */
2450 void cmd_init(int terminal
)
2452 struct utsname names
;
2457 /* register command preprocessors */
2458 hook_register(cmd_execute
, handle_pipe_action
);
2459 hook_register(cmd_execute_done
, handle_pipe_action_done
);
2461 varhandlers
= list_new();
2463 /* Allocate initial top vector of commands. */
2464 cmdvec
= vector_init(VECTOR_MIN_SIZE
);
2466 /* Default host value settings. */
2467 host
.name
= XSTRDUP(MTYPE_HOST
, names
.nodename
);
2468 host
.system
= XSTRDUP(MTYPE_HOST
, names
.sysname
);
2469 host
.release
= XSTRDUP(MTYPE_HOST
, names
.release
);
2470 host
.version
= XSTRDUP(MTYPE_HOST
, names
.version
);
2472 #ifdef HAVE_STRUCT_UTSNAME_DOMAINNAME
2473 if ((strcmp(names
.domainname
, "(none)") == 0))
2474 host
.domainname
= NULL
;
2476 host
.domainname
= XSTRDUP(MTYPE_HOST
, names
.domainname
);
2478 host
.domainname
= NULL
;
2480 host
.password
= NULL
;
2483 host
.noconfig
= (terminal
< 0);
2485 cmd_banner_motd_line(FRR_DEFAULT_MOTD
);
2486 host
.motdfile
= NULL
;
2488 /* Install top nodes. */
2489 install_node(&view_node
);
2490 install_node(&enable_node
);
2491 install_node(&auth_node
);
2492 install_node(&auth_enable_node
);
2493 install_node(&config_node
);
2495 /* Each node's basic commands. */
2496 install_element(VIEW_NODE
, &show_version_cmd
);
2497 install_element(ENABLE_NODE
, &show_startup_config_cmd
);
2500 install_element(ENABLE_NODE
, &debug_memstats_cmd
);
2502 install_element(VIEW_NODE
, &config_list_cmd
);
2503 install_element(VIEW_NODE
, &config_exit_cmd
);
2504 install_element(VIEW_NODE
, &config_quit_cmd
);
2505 install_element(VIEW_NODE
, &config_help_cmd
);
2506 install_element(VIEW_NODE
, &config_enable_cmd
);
2507 install_element(VIEW_NODE
, &config_terminal_length_cmd
);
2508 install_element(VIEW_NODE
, &config_terminal_no_length_cmd
);
2509 install_element(VIEW_NODE
, &show_commandtree_cmd
);
2510 install_element(VIEW_NODE
, &echo_cmd
);
2511 install_element(VIEW_NODE
, &autocomplete_cmd
);
2512 install_element(VIEW_NODE
, &find_cmd
);
2513 #if defined(DEV_BUILD) && defined(HAVE_SCRIPTING)
2514 install_element(VIEW_NODE
, &script_cmd
);
2518 install_element(ENABLE_NODE
, &config_end_cmd
);
2519 install_element(ENABLE_NODE
, &config_disable_cmd
);
2520 install_element(ENABLE_NODE
, &config_terminal_cmd
);
2521 install_element(ENABLE_NODE
, ©_runningconf_startupconf_cmd
);
2522 install_element(ENABLE_NODE
, &config_write_cmd
);
2523 install_element(ENABLE_NODE
, &show_running_config_cmd
);
2524 install_element(ENABLE_NODE
, &config_logmsg_cmd
);
2526 install_default(CONFIG_NODE
);
2529 workqueue_cmd_init();
2533 install_element(CONFIG_NODE
, &hostname_cmd
);
2534 install_element(CONFIG_NODE
, &no_hostname_cmd
);
2535 install_element(CONFIG_NODE
, &domainname_cmd
);
2536 install_element(CONFIG_NODE
, &no_domainname_cmd
);
2541 install_element(CONFIG_NODE
, &debug_memstats_cmd
);
2543 install_element(CONFIG_NODE
, &password_cmd
);
2544 install_element(CONFIG_NODE
, &no_password_cmd
);
2545 install_element(CONFIG_NODE
, &enable_password_cmd
);
2546 install_element(CONFIG_NODE
, &no_enable_password_cmd
);
2548 install_element(CONFIG_NODE
, &service_password_encrypt_cmd
);
2549 install_element(CONFIG_NODE
, &no_service_password_encrypt_cmd
);
2550 install_element(CONFIG_NODE
, &banner_motd_default_cmd
);
2551 install_element(CONFIG_NODE
, &banner_motd_file_cmd
);
2552 install_element(CONFIG_NODE
, &banner_motd_line_cmd
);
2553 install_element(CONFIG_NODE
, &no_banner_motd_cmd
);
2554 install_element(CONFIG_NODE
, &service_terminal_length_cmd
);
2555 install_element(CONFIG_NODE
, &no_service_terminal_length_cmd
);
2558 vrf_install_commands();
2562 grammar_sandbox_init();
2566 void cmd_terminate(void)
2568 struct cmd_node
*cmd_node
;
2570 hook_unregister(cmd_execute
, handle_pipe_action
);
2571 hook_unregister(cmd_execute_done
, handle_pipe_action_done
);
2574 for (unsigned int i
= 0; i
< vector_active(cmdvec
); i
++)
2575 if ((cmd_node
= vector_slot(cmdvec
, i
)) != NULL
) {
2576 // deleting the graph delets the cmd_element as
2578 graph_delete_graph(cmd_node
->cmdgraph
);
2579 vector_free(cmd_node
->cmd_vector
);
2580 hash_clean(cmd_node
->cmd_hash
, NULL
);
2581 hash_free(cmd_node
->cmd_hash
);
2582 cmd_node
->cmd_hash
= NULL
;
2585 vector_free(cmdvec
);
2589 XFREE(MTYPE_HOST
, host
.name
);
2590 XFREE(MTYPE_HOST
, host
.system
);
2591 XFREE(MTYPE_HOST
, host
.release
);
2592 XFREE(MTYPE_HOST
, host
.version
);
2593 XFREE(MTYPE_HOST
, host
.domainname
);
2594 XFREE(MTYPE_HOST
, host
.password
);
2595 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2596 XFREE(MTYPE_HOST
, host
.enable
);
2597 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2598 XFREE(MTYPE_HOST
, host
.motdfile
);
2599 XFREE(MTYPE_HOST
, host
.config
);
2600 XFREE(MTYPE_HOST
, host
.motd
);
2602 list_delete(&varhandlers
);