1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * CLI backend interface.
6 * Copyright (C) 2016 Cumulus Networks, Inc.
7 * Copyright (C) 1997, 98, 99 Kunihiro Ishiguro
8 * Copyright (C) 2013 by Open Source Routing.
9 * Copyright (C) 2013 by Internet Systems Consortium, Inc. ("ISC")
13 #include <lib/version.h>
24 #include "workqueue.h"
26 #include "command_match.h"
27 #include "command_graph.h"
33 #include "lib_errors.h"
34 #include "mgmt_be_client.h"
35 #include "mgmt_fe_client.h"
36 #include "northbound_cli.h"
40 #include "frrscript.h"
42 DEFINE_MTYPE_STATIC(LIB
, HOST
, "Host config");
43 DEFINE_MTYPE(LIB
, COMPLETION
, "Completion item");
50 /* clang-format off */
51 const struct message tokennames
[] = {
56 item(IPV4_PREFIX_TKN
),
58 item(IPV6_PREFIX_TKN
),
71 /* Command vector which includes some level of command lists. Normally
72 each daemon maintains each own cmdvec. */
75 /* Host information structure. */
78 /* for vtysh, put together CLI trees only when switching into node */
79 static bool defer_cli_tree
;
82 * Returns host.name if any, otherwise
83 * it returns the system hostname.
85 const char *cmd_hostname_get(void)
91 * Returns unix domainname
93 const char *cmd_domainname_get(void)
95 return host
.domainname
;
98 const char *cmd_system_get(void)
103 const char *cmd_release_get(void)
108 const char *cmd_version_get(void)
113 bool cmd_allow_reserved_ranges_get(void)
115 return host
.allow_reserved_ranges
;
118 const char *cmd_software_version_get(void)
120 return FRR_FULL_NAME
"/" FRR_VERSION
;
123 static int root_on_exit(struct vty
*vty
);
125 /* Standard command node structures. */
126 static struct cmd_node auth_node
= {
129 .prompt
= "Password: ",
132 static struct cmd_node view_node
= {
136 .node_exit
= root_on_exit
,
139 static struct cmd_node auth_enable_node
= {
140 .name
= "auth enable",
141 .node
= AUTH_ENABLE_NODE
,
142 .prompt
= "Password: ",
145 static struct cmd_node enable_node
= {
149 .node_exit
= root_on_exit
,
152 static int config_write_host(struct vty
*vty
);
153 static struct cmd_node config_node
= {
156 .parent_node
= ENABLE_NODE
,
157 .prompt
= "%s(config)# ",
158 .config_write
= config_write_host
,
159 .node_exit
= vty_config_node_exit
,
162 /* This is called from main when a daemon is invoked with -v or --version. */
163 void print_version(const char *progname
)
165 printf("%s version %s\n", progname
, FRR_VERSION
);
166 printf("%s\n", FRR_COPYRIGHT
);
167 #ifdef ENABLE_VERSION_BUILD_CONFIG
168 printf("configured with:\n\t%s\n", FRR_CONFIG_ARGS
);
172 char *argv_concat(struct cmd_token
**argv
, int argc
, int shift
)
174 int cnt
= MAX(argc
- shift
, 0);
175 const char *argstr
[cnt
+ 1];
180 for (int i
= 0; i
< cnt
; i
++)
181 argstr
[i
] = argv
[i
+ shift
]->arg
;
183 return frrstr_join(argstr
, cnt
, " ");
186 vector
cmd_make_strvec(const char *string
)
191 const char *copy
= string
;
193 /* skip leading whitespace */
194 while (isspace((unsigned char)*copy
) && *copy
!= '\0')
197 /* if the entire string was whitespace or a comment, return */
198 if (*copy
== '\0' || *copy
== '!' || *copy
== '#')
201 vector result
= frrstr_split_vec(copy
, "\n\r\t ");
203 for (unsigned int i
= 0; i
< vector_active(result
); i
++) {
204 if (strlen(vector_slot(result
, i
)) == 0) {
205 XFREE(MTYPE_TMP
, vector_slot(result
, i
));
206 vector_unset(result
, i
);
210 vector_compact(result
);
215 void cmd_free_strvec(vector v
)
217 frrstr_strvec_free(v
);
221 * Convenience function for accessing argv data.
225 * @param text definition snippet of the desired token
226 * @param index the starting index, and where to store the
227 * index of the found token if it exists
228 * @return 1 if found, 0 otherwise
230 int argv_find(struct cmd_token
**argv
, int argc
, const char *text
, int *index
)
233 for (int i
= *index
; i
< argc
&& found
== 0; i
++)
234 if ((found
= strmatch(text
, argv
[i
]->text
)))
239 static unsigned int cmd_hash_key(const void *p
)
241 int size
= sizeof(p
);
243 return jhash(p
, size
, 0);
246 static bool cmd_hash_cmp(const void *a
, const void *b
)
251 /* Install top node of command vector. */
252 void install_node(struct cmd_node
*node
)
254 #define CMD_HASH_STR_SIZE 256
255 char hash_name
[CMD_HASH_STR_SIZE
];
257 vector_set_index(cmdvec
, node
->node
, node
);
258 node
->cmdgraph
= graph_new();
259 node
->cmd_vector
= vector_init(VECTOR_MIN_SIZE
);
261 struct cmd_token
*token
= cmd_token_new(START_TKN
, 0, NULL
, NULL
);
262 graph_new_node(node
->cmdgraph
, token
,
263 (void (*)(void *)) & cmd_token_del
);
265 snprintf(hash_name
, sizeof(hash_name
), "Command Hash: %s", node
->name
);
267 hash_create_size(16, cmd_hash_key
, cmd_hash_cmp
, hash_name
);
270 /* Return prompt character of specified node. */
271 const char *cmd_prompt(enum node_type node
)
273 struct cmd_node
*cnode
;
275 cnode
= vector_slot(cmdvec
, node
);
276 return cnode
->prompt
;
279 void cmd_defer_tree(bool val
)
281 defer_cli_tree
= val
;
284 /* Install a command into a node. */
285 void _install_element(enum node_type ntype
, const struct cmd_element
*cmd
)
287 struct cmd_node
*cnode
;
289 /* cmd_init hasn't been called */
291 fprintf(stderr
, "%s called before cmd_init, breakage likely\n",
296 cnode
= vector_lookup(cmdvec
, ntype
);
301 "\tnode %d does not exist.\n"
302 "\tplease call install_node() before install_element()\n",
303 cmd
->name
, cmd
->string
, ntype
);
307 if (hash_lookup(cnode
->cmd_hash
, (void *)cmd
) != NULL
) {
310 "\tnode %d (%s) already has this command installed.\n"
311 "\tduplicate install_element call?\n",
312 cmd
->name
, cmd
->string
, ntype
, cnode
->name
);
316 (void)hash_get(cnode
->cmd_hash
, (void *)cmd
, hash_alloc_intern
);
318 if (cnode
->graph_built
|| !defer_cli_tree
) {
319 struct graph
*graph
= graph_new();
320 struct cmd_token
*token
=
321 cmd_token_new(START_TKN
, 0, NULL
, NULL
);
322 graph_new_node(graph
, token
,
323 (void (*)(void *)) & cmd_token_del
);
325 cmd_graph_parse(graph
, cmd
);
326 cmd_graph_names(graph
);
327 cmd_graph_merge(cnode
->cmdgraph
, graph
, +1);
328 graph_delete_graph(graph
);
330 cnode
->graph_built
= true;
333 vector_set(cnode
->cmd_vector
, (void *)cmd
);
335 if (ntype
== VIEW_NODE
)
336 _install_element(ENABLE_NODE
, cmd
);
339 static void cmd_finalize_iter(struct hash_bucket
*hb
, void *arg
)
341 struct cmd_node
*cnode
= arg
;
342 const struct cmd_element
*cmd
= hb
->data
;
343 struct graph
*graph
= graph_new();
344 struct cmd_token
*token
= cmd_token_new(START_TKN
, 0, NULL
, NULL
);
346 graph_new_node(graph
, token
, (void (*)(void *)) & cmd_token_del
);
348 cmd_graph_parse(graph
, cmd
);
349 cmd_graph_names(graph
);
350 cmd_graph_merge(cnode
->cmdgraph
, graph
, +1);
351 graph_delete_graph(graph
);
354 void cmd_finalize_node(struct cmd_node
*cnode
)
356 if (cnode
->graph_built
)
359 hash_iterate(cnode
->cmd_hash
, cmd_finalize_iter
, cnode
);
360 cnode
->graph_built
= true;
363 void uninstall_element(enum node_type ntype
, const struct cmd_element
*cmd
)
365 struct cmd_node
*cnode
;
367 /* cmd_init hasn't been called */
369 fprintf(stderr
, "%s called before cmd_init, breakage likely\n",
374 cnode
= vector_lookup(cmdvec
, ntype
);
379 "\tnode %d does not exist.\n"
380 "\tplease call install_node() before uninstall_element()\n",
381 cmd
->name
, cmd
->string
, ntype
);
385 if (hash_release(cnode
->cmd_hash
, (void *)cmd
) == NULL
) {
388 "\tnode %d (%s) does not have this command installed.\n"
389 "\tduplicate uninstall_element call?\n",
390 cmd
->name
, cmd
->string
, ntype
, cnode
->name
);
394 vector_unset_value(cnode
->cmd_vector
, (void *)cmd
);
396 if (cnode
->graph_built
) {
397 struct graph
*graph
= graph_new();
398 struct cmd_token
*token
=
399 cmd_token_new(START_TKN
, 0, NULL
, NULL
);
400 graph_new_node(graph
, token
,
401 (void (*)(void *)) & cmd_token_del
);
403 cmd_graph_parse(graph
, cmd
);
404 cmd_graph_names(graph
);
405 cmd_graph_merge(cnode
->cmdgraph
, graph
, -1);
406 graph_delete_graph(graph
);
409 if (ntype
== VIEW_NODE
)
410 uninstall_element(ENABLE_NODE
, cmd
);
414 static const unsigned char itoa64
[] =
415 "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
417 static void to64(char *s
, long v
, int n
)
420 *s
++ = itoa64
[v
& 0x3f];
425 static char *zencrypt(const char *passwd
)
430 gettimeofday(&tv
, 0);
432 to64(&salt
[0], frr_weak_random(), 3);
433 to64(&salt
[3], tv
.tv_usec
, 3);
436 return crypt(passwd
, salt
);
439 static bool full_cli
;
441 /* This function write configuration of this host. */
442 static int config_write_host(struct vty
*vty
)
446 name
= cmd_hostname_get();
447 if (name
&& name
[0] != '\0')
448 vty_out(vty
, "hostname %s\n", name
);
450 name
= cmd_domainname_get();
451 if (name
&& name
[0] != '\0')
452 vty_out(vty
, "domainname %s\n", name
);
454 if (cmd_allow_reserved_ranges_get())
455 vty_out(vty
, "allow-reserved-ranges\n");
457 /* The following are all configuration commands that are not sent to
458 * watchfrr. For instance watchfrr is hardcoded to log to syslog so
459 * we would always display 'log syslog informational' in the config
460 * which would cause other daemons to then switch to syslog when they
465 if (host
.password_encrypt
)
466 vty_out(vty
, "password 8 %s\n",
467 host
.password_encrypt
);
468 if (host
.enable_encrypt
)
469 vty_out(vty
, "enable password 8 %s\n",
470 host
.enable_encrypt
);
473 vty_out(vty
, "password %s\n", host
.password
);
475 vty_out(vty
, "enable password %s\n",
478 log_config_write(vty
);
480 /* print disable always, but enable only if default is flipped
481 * => prep for future removal of compile-time knob
483 if (!cputime_enabled
)
484 vty_out(vty
, "no service cputime-stats\n");
485 #ifdef EXCLUDE_CPU_TIME
487 vty_out(vty
, "service cputime-stats\n");
490 if (!cputime_threshold
)
491 vty_out(vty
, "no service cputime-warning\n");
492 #if defined(CONSUMED_TIME_CHECK) && CONSUMED_TIME_CHECK != 5000000
493 else /* again, always print non-default */
495 else if (cputime_threshold
!= 5000000)
497 vty_out(vty
, "service cputime-warning %lu\n",
498 cputime_threshold
/ 1000);
500 if (!walltime_threshold
)
501 vty_out(vty
, "no service walltime-warning\n");
502 #if defined(CONSUMED_TIME_CHECK) && CONSUMED_TIME_CHECK != 5000000
503 else /* again, always print non-default */
505 else if (walltime_threshold
!= 5000000)
507 vty_out(vty
, "service walltime-warning %lu\n",
508 walltime_threshold
/ 1000);
511 vty_out(vty
, "service advanced-vty\n");
514 vty_out(vty
, "service password-encryption\n");
517 vty_out(vty
, "service terminal-length %d\n",
521 vty_out(vty
, "banner motd file %s\n", host
.motdfile
);
523 && strncmp(host
.motd
, FRR_DEFAULT_MOTD
,
525 vty_out(vty
, "banner motd line %s\n", host
.motd
);
527 vty_out(vty
, "no banner motd\n");
530 if (debug_memstats_at_exit
)
531 vty_out(vty
, "!\ndebug memstats-at-exit\n");
536 /* Utility function for getting command graph. */
537 static struct graph
*cmd_node_graph(vector v
, enum node_type ntype
)
539 struct cmd_node
*cnode
= vector_slot(v
, ntype
);
541 cmd_finalize_node(cnode
);
542 return cnode
->cmdgraph
;
545 static int cmd_try_do_shortcut(enum node_type node
, char *first_word
)
547 if (first_word
!= NULL
&& node
!= AUTH_NODE
&& node
!= VIEW_NODE
548 && node
!= AUTH_ENABLE_NODE
&& 0 == strcmp("do", first_word
))
554 * Compare function for cmd_token.
555 * Used with qsort to sort command completions.
557 static int compare_completions(const void *fst
, const void *snd
)
559 const struct cmd_token
*first
= *(const struct cmd_token
* const *)fst
,
560 *secnd
= *(const struct cmd_token
* const *)snd
;
561 return strcmp(first
->text
, secnd
->text
);
565 * Takes a list of completions returned by command_complete,
566 * dedeuplicates them based on both text and description,
567 * sorts them, and returns them as a vector.
569 * @param completions linked list of cmd_token
570 * @return deduplicated and sorted vector with
572 vector
completions_to_vec(struct list
*completions
)
574 vector comps
= vector_init(VECTOR_MIN_SIZE
);
577 struct cmd_token
*token
, *cr
= NULL
;
578 unsigned int i
, exists
;
579 for (ALL_LIST_ELEMENTS_RO(completions
, ln
, token
)) {
580 if (token
->type
== END_TKN
&& (cr
= token
))
583 // linear search for token in completions vector
585 for (i
= 0; i
< vector_active(comps
) && !exists
; i
++) {
586 struct cmd_token
*curr
= vector_slot(comps
, i
);
588 exists
= !strcmp(curr
->text
, token
->text
)
589 && !strcmp(curr
->desc
, token
->desc
);
591 exists
= !strcmp(curr
->text
, token
->text
);
592 #endif /* VTYSH_DEBUG */
596 vector_set(comps
, token
);
600 qsort(comps
->index
, vector_active(comps
), sizeof(void *),
601 &compare_completions
);
603 // make <cr> the first element, if it is present
605 vector_set_index(comps
, vector_active(comps
), NULL
);
606 memmove(comps
->index
+ 1, comps
->index
,
607 (comps
->alloced
- 1) * sizeof(void *));
608 vector_set_index(comps
, 0, cr
);
614 * Generates a vector of cmd_token representing possible completions
615 * on the current input.
617 * @param vline the vectorized input line
618 * @param vty the vty with the node to match on
619 * @param status pointer to matcher status code
620 * @return vector of struct cmd_token * with possible completions
622 static vector
cmd_complete_command_real(vector vline
, struct vty
*vty
,
625 struct list
*completions
;
626 struct graph
*cmdgraph
= cmd_node_graph(cmdvec
, vty
->node
);
628 enum matcher_rv rv
= command_complete(cmdgraph
, vline
, &completions
);
630 if (MATCHER_ERROR(rv
)) {
631 *status
= CMD_ERR_NO_MATCH
;
635 vector comps
= completions_to_vec(completions
);
636 list_delete(&completions
);
638 // set status code appropriately
639 switch (vector_active(comps
)) {
641 *status
= CMD_ERR_NO_MATCH
;
644 *status
= CMD_COMPLETE_FULL_MATCH
;
647 *status
= CMD_COMPLETE_LIST_MATCH
;
653 vector
cmd_describe_command(vector vline
, struct vty
*vty
, int *status
)
657 if (cmd_try_do_shortcut(vty
->node
, vector_slot(vline
, 0))) {
658 enum node_type onode
;
659 int orig_xpath_index
;
660 vector shifted_vline
;
664 orig_xpath_index
= vty
->xpath_index
;
665 vty
->node
= ENABLE_NODE
;
666 vty
->xpath_index
= 0;
667 /* We can try it on enable node, cos' the vty is authenticated
670 shifted_vline
= vector_init(vector_count(vline
));
672 for (index
= 1; index
< vector_active(vline
); index
++) {
673 vector_set_index(shifted_vline
, index
- 1,
674 vector_lookup(vline
, index
));
677 ret
= cmd_complete_command_real(shifted_vline
, vty
, status
);
679 vector_free(shifted_vline
);
681 vty
->xpath_index
= orig_xpath_index
;
685 return cmd_complete_command_real(vline
, vty
, status
);
688 static struct list
*varhandlers
= NULL
;
690 void cmd_variable_complete(struct cmd_token
*token
, const char *arg
,
694 const struct cmd_variable_handler
*cvh
;
698 tmpcomps
= arg
? vector_init(VECTOR_MIN_SIZE
) : comps
;
700 for (ALL_LIST_ELEMENTS_RO(varhandlers
, ln
, cvh
)) {
701 if (cvh
->tokenname
&& strcmp(cvh
->tokenname
, token
->text
))
703 if (cvh
->varname
&& (!token
->varname
704 || strcmp(cvh
->varname
, token
->varname
)))
706 cvh
->completions(tmpcomps
, token
);
714 for (i
= vector_active(tmpcomps
); i
; i
--) {
715 char *item
= vector_slot(tmpcomps
, i
- 1);
716 if (strlen(item
) >= argsz
&& !strncmp(item
, arg
, argsz
))
717 vector_set(comps
, item
);
719 XFREE(MTYPE_COMPLETION
, item
);
721 vector_free(tmpcomps
);
724 #define AUTOCOMP_INDENT 5
726 char *cmd_variable_comp2str(vector comps
, unsigned short cols
)
729 char *buf
= XCALLOC(MTYPE_TMP
, bsz
);
730 int lc
= AUTOCOMP_INDENT
;
731 size_t cs
= AUTOCOMP_INDENT
;
733 snprintf(buf
, bsz
, "%*s", AUTOCOMP_INDENT
, "");
734 for (size_t j
= 0; j
< vector_active(comps
); j
++) {
735 char *item
= vector_slot(comps
, j
);
736 itemlen
= strlen(item
);
738 if (cs
+ itemlen
+ AUTOCOMP_INDENT
+ 3 >= bsz
)
739 buf
= XREALLOC(MTYPE_TMP
, buf
, (bsz
*= 2));
741 if (lc
+ itemlen
+ 1 >= cols
) {
742 cs
+= snprintf(&buf
[cs
], bsz
- cs
, "\n%*s",
743 AUTOCOMP_INDENT
, "");
744 lc
= AUTOCOMP_INDENT
;
747 size_t written
= snprintf(&buf
[cs
], bsz
- cs
, "%s ", item
);
750 XFREE(MTYPE_COMPLETION
, item
);
751 vector_set_index(comps
, j
, NULL
);
756 void cmd_variable_handler_register(const struct cmd_variable_handler
*cvh
)
761 for (; cvh
->completions
; cvh
++)
762 listnode_add(varhandlers
, (void *)cvh
);
765 DEFUN_HIDDEN (autocomplete
,
767 "autocomplete TYPE TEXT VARNAME",
768 "Autocompletion handler (internal, for vtysh)\n"
771 "cmd_token->varname\n")
773 struct cmd_token tok
;
774 vector comps
= vector_init(32);
777 memset(&tok
, 0, sizeof(tok
));
778 tok
.type
= atoi(argv
[1]->arg
);
779 tok
.text
= argv
[2]->arg
;
780 tok
.varname
= argv
[3]->arg
;
781 if (!strcmp(tok
.varname
, "-"))
784 cmd_variable_complete(&tok
, NULL
, comps
);
786 for (i
= 0; i
< vector_active(comps
); i
++) {
787 char *text
= vector_slot(comps
, i
);
788 vty_out(vty
, "%s\n", text
);
789 XFREE(MTYPE_COMPLETION
, text
);
797 * Generate possible tab-completions for the given input. This function only
798 * returns results that would result in a valid command if used as Readline
799 * completions (as is the case in vtysh). For instance, if the passed vline ends
800 * with '4.3.2', the strings 'A.B.C.D' and 'A.B.C.D/M' will _not_ be returned.
802 * @param vline vectorized input line
804 * @param status location to store matcher status code in
805 * @return set of valid strings for use with Readline as tab-completions.
808 char **cmd_complete_command(vector vline
, struct vty
*vty
, int *status
)
811 int original_node
= vty
->node
;
812 vector input_line
= vector_init(vector_count(vline
));
814 // if the first token is 'do' we'll want to execute the command in the
816 int do_shortcut
= cmd_try_do_shortcut(vty
->node
, vector_slot(vline
, 0));
817 vty
->node
= do_shortcut
? ENABLE_NODE
: original_node
;
819 // construct the input line we'll be matching on
820 unsigned int offset
= (do_shortcut
) ? 1 : 0;
821 for (unsigned index
= 0; index
+ offset
< vector_active(vline
); index
++)
822 vector_set_index(input_line
, index
,
823 vector_lookup(vline
, index
+ offset
));
825 // get token completions -- this is a copying operation
826 vector comps
= NULL
, initial_comps
;
827 initial_comps
= cmd_complete_command_real(input_line
, vty
, status
);
829 if (!MATCHER_ERROR(*status
)) {
830 assert(initial_comps
);
831 // filter out everything that is not suitable for a
833 comps
= vector_init(VECTOR_MIN_SIZE
);
834 for (unsigned int i
= 0; i
< vector_active(initial_comps
);
836 struct cmd_token
*token
= vector_slot(initial_comps
, i
);
837 if (token
->type
== WORD_TKN
)
838 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
,
840 else if (IS_VARYING_TOKEN(token
->type
)) {
841 const char *ref
= vector_lookup(
842 vline
, vector_active(vline
) - 1);
843 cmd_variable_complete(token
, ref
, comps
);
846 vector_free(initial_comps
);
848 // since we filtered results, we need to re-set status code
849 switch (vector_active(comps
)) {
851 *status
= CMD_ERR_NO_MATCH
;
854 *status
= CMD_COMPLETE_FULL_MATCH
;
857 *status
= CMD_COMPLETE_LIST_MATCH
;
860 // copy completions text into an array of char*
861 ret
= XMALLOC(MTYPE_TMP
,
862 (vector_active(comps
) + 1) * sizeof(char *));
864 for (i
= 0; i
< vector_active(comps
); i
++) {
865 ret
[i
] = vector_slot(comps
, i
);
867 // set the last element to NULL, because this array is used in
868 // a Readline completion_generator function which expects NULL
869 // as a sentinel value
873 } else if (initial_comps
)
874 vector_free(initial_comps
);
876 // comps should always be null here
879 // free the adjusted input line
880 vector_free(input_line
);
882 // reset vty->node to its original value
883 vty
->node
= original_node
;
888 /* return parent node */
889 /* MUST eventually converge on CONFIG_NODE */
890 enum node_type
node_parent(enum node_type node
)
892 struct cmd_node
*cnode
;
894 assert(node
> CONFIG_NODE
);
896 cnode
= vector_lookup(cmdvec
, node
);
898 return cnode
->parent_node
;
901 /* Execute command by argument vline vector. */
902 static int cmd_execute_command_real(vector vline
, enum cmd_filter_type filter
,
904 const struct cmd_element
**cmd
,
905 unsigned int up_level
)
907 struct list
*argv_list
;
908 enum matcher_rv status
;
909 const struct cmd_element
*matched_element
= NULL
;
911 int xpath_index
= vty
->xpath_index
;
912 int node
= vty
->node
;
914 /* only happens for legacy split config file load; need to check for
915 * a match before calling node_exit handlers below
917 for (i
= 0; i
< up_level
; i
++) {
918 struct cmd_node
*cnode
;
920 if (node
<= CONFIG_NODE
)
921 return CMD_NO_LEVEL_UP
;
923 cnode
= vector_slot(cmdvec
, node
);
924 node
= node_parent(node
);
926 if (xpath_index
> 0 && !cnode
->no_xpath
)
930 struct graph
*cmdgraph
= cmd_node_graph(cmdvec
, node
);
931 status
= command_match(cmdgraph
, vline
, &argv_list
, &matched_element
);
934 *cmd
= matched_element
;
936 // if matcher error, return corresponding CMD_ERR
937 if (MATCHER_ERROR(status
)) {
939 list_delete(&argv_list
);
941 case MATCHER_INCOMPLETE
:
942 return CMD_ERR_INCOMPLETE
;
943 case MATCHER_AMBIGUOUS
:
944 return CMD_ERR_AMBIGUOUS
;
945 case MATCHER_NO_MATCH
:
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 if (vty_log_commands
) {
1307 int len
= strlen(vty
->buf
);
1309 /* now log the command */
1310 zlog_notice("config-from-file# %.*s", len
? len
- 1 : 0,
1314 ret
= command_config_read_one_line(vty
, NULL
, *line_num
, 0);
1316 if (ret
!= CMD_SUCCESS
&& ret
!= CMD_WARNING
1317 && ret
!= CMD_ERR_NOTHING_TODO
)
1328 /* Configuration from terminal */
1329 DEFUN (config_terminal
,
1330 config_terminal_cmd
,
1331 "configure [terminal]",
1332 "Configuration from vty interface\n"
1333 "Configuration terminal\n")
1335 return vty_config_enter(vty
, false, false);
1338 /* Enable command */
1342 "Turn on privileged mode command\n")
1344 /* If enable password is NULL, change to ENABLE_NODE */
1345 if ((host
.enable
== NULL
&& host
.enable_encrypt
== NULL
)
1346 || vty
->type
== VTY_SHELL_SERV
)
1347 vty
->node
= ENABLE_NODE
;
1349 vty
->node
= AUTH_ENABLE_NODE
;
1354 /* Disable command */
1358 "Turn off privileged mode command\n")
1360 if (vty
->node
== ENABLE_NODE
)
1361 vty
->node
= VIEW_NODE
;
1365 /* Down vty node level. */
1369 "Exit current mode and down to previous mode\n")
1375 static int root_on_exit(struct vty
*vty
)
1380 vty
->status
= VTY_CLOSE
;
1384 void cmd_exit(struct vty
*vty
)
1386 struct cmd_node
*cnode
= vector_lookup(cmdvec
, vty
->node
);
1388 if (cnode
->node_exit
) {
1389 if (!cnode
->node_exit(vty
))
1392 if (cnode
->parent_node
)
1393 vty
->node
= cnode
->parent_node
;
1394 if (vty
->xpath_index
> 0 && !cnode
->no_xpath
)
1402 "Exit current mode and down to previous mode\n")
1404 return config_exit(self
, vty
, argc
, argv
);
1408 /* End of configuration. */
1412 "End current mode and change to enable mode.\n")
1415 vty_config_exit(vty
);
1416 vty
->node
= ENABLE_NODE
;
1422 DEFUN (show_version
,
1426 "Displays zebra version\n")
1428 vty_out(vty
, "%s %s (%s) on %s(%s).\n", FRR_FULL_NAME
, FRR_VERSION
,
1429 cmd_hostname_get() ? cmd_hostname_get() : "", cmd_system_get(),
1431 vty_out(vty
, "%s%s\n", FRR_COPYRIGHT
, GIT_INFO
);
1432 #ifdef ENABLE_VERSION_BUILD_CONFIG
1433 vty_out(vty
, "configured with:\n %s\n", FRR_CONFIG_ARGS
);
1438 /* Help display function for all node. */
1442 "Description of the interactive help system\n")
1445 "Quagga VTY provides advanced help feature. When you need help,\n\
1446 anytime at the command line please press '?'.\n\
1448 If nothing matches, the help list will be empty and you must backup\n\
1449 until entering a '?' shows the available options.\n\
1450 Two styles of help are provided:\n\
1451 1. Full help is available when you are ready to enter a\n\
1452 command argument (e.g. 'show ?') and describes each possible\n\
1454 2. Partial help is provided when an abbreviated argument is entered\n\
1455 and you want to know what arguments match the input\n\
1456 (e.g. 'show me?'.)\n\n");
1460 static void permute(struct graph_node
*start
, struct vty
*vty
)
1462 static struct list
*position
= NULL
;
1464 position
= list_new();
1466 struct cmd_token
*stok
= start
->data
;
1467 struct graph_node
*gnn
;
1468 struct listnode
*ln
;
1471 listnode_add(position
, start
);
1472 for (unsigned int i
= 0; i
< vector_active(start
->to
); i
++) {
1473 struct graph_node
*gn
= vector_slot(start
->to
, i
);
1474 struct cmd_token
*tok
= gn
->data
;
1475 if (tok
->attr
& CMD_ATTR_HIDDEN
)
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_HIDDEN
)) {
1567 print_cmd(vty
, element
->string
);
1573 /* Help display function for all node. */
1576 "list [permutations]",
1577 "Print command list\n"
1578 "Print all possible command permutations\n")
1580 return cmd_list_cmds(vty
, argc
== 2);
1583 DEFUN (show_commandtree
,
1584 show_commandtree_cmd
,
1585 "show commandtree [permutations]",
1587 "Show command tree\n"
1588 "Permutations that we are interested in\n")
1590 return cmd_list_cmds(vty
, argc
== 3);
1593 DEFUN_HIDDEN(show_cli_graph
,
1598 "Dump current command space as DOT graph\n")
1600 struct cmd_node
*cn
= vector_slot(cmdvec
, vty
->node
);
1603 cmd_finalize_node(cn
);
1604 dot
= cmd_graph_dump_dot(cn
->cmdgraph
);
1606 vty_out(vty
, "%s\n", dot
);
1607 XFREE(MTYPE_TMP
, dot
);
1611 static int vty_write_config(struct vty
*vty
)
1614 struct cmd_node
*node
;
1619 nb_cli_show_config_prepare(running_config
, false);
1621 if (vty
->type
== VTY_TERM
) {
1622 vty_out(vty
, "\nCurrent configuration:\n");
1623 vty_out(vty
, "!\n");
1626 if (strcmp(frr_defaults_version(), FRR_VER_SHORT
))
1627 vty_out(vty
, "! loaded from %s\n", frr_defaults_version());
1628 vty_out(vty
, "frr version %s\n", FRR_VER_SHORT
);
1629 vty_out(vty
, "frr defaults %s\n", frr_defaults_profile());
1630 vty_out(vty
, "!\n");
1632 for (i
= 0; i
< vector_active(cmdvec
); i
++)
1633 if ((node
= vector_slot(cmdvec
, i
)) && node
->config_write
) {
1634 if ((*node
->config_write
)(vty
))
1635 vty_out(vty
, "!\n");
1638 if (vty
->type
== VTY_TERM
) {
1639 vty_out(vty
, "end\n");
1645 static int file_write_config(struct vty
*vty
)
1648 char *config_file
, *slash
;
1649 char *config_file_tmp
= NULL
;
1650 char *config_file_sav
= NULL
;
1651 int ret
= CMD_WARNING
;
1652 struct vty
*file_vty
;
1653 struct stat conf_stat
;
1658 /* Check and see if we are operating under vtysh configuration */
1659 if (host
.config
== NULL
) {
1661 "Can't save to configuration file, using vtysh.\n");
1666 config_file
= host
.config
;
1669 #define O_DIRECTORY 0
1671 slash
= strrchr(config_file
, '/');
1673 char *config_dir
= XSTRDUP(MTYPE_TMP
, config_file
);
1674 config_dir
[slash
- config_file
] = '\0';
1675 dirfd
= open(config_dir
, O_DIRECTORY
| O_RDONLY
);
1676 XFREE(MTYPE_TMP
, config_dir
);
1678 dirfd
= open(".", O_DIRECTORY
| O_RDONLY
);
1679 /* if dirfd is invalid, directory sync fails, but we're still OK */
1681 size_t config_file_sav_sz
= strlen(config_file
) + strlen(CONF_BACKUP_EXT
) + 1;
1682 config_file_sav
= XMALLOC(MTYPE_TMP
, config_file_sav_sz
);
1683 strlcpy(config_file_sav
, config_file
, config_file_sav_sz
);
1684 strlcat(config_file_sav
, CONF_BACKUP_EXT
, config_file_sav_sz
);
1687 config_file_tmp
= XMALLOC(MTYPE_TMP
, strlen(config_file
) + 8);
1688 snprintf(config_file_tmp
, strlen(config_file
) + 8, "%s.XXXXXX",
1691 /* Open file to configuration write. */
1692 fd
= mkstemp(config_file_tmp
);
1694 vty_out(vty
, "Can't open configuration file %s.\n",
1698 if (fchmod(fd
, CONFIGFILE_MASK
) != 0) {
1699 vty_out(vty
, "Can't chmod configuration file %s: %s (%d).\n",
1700 config_file_tmp
, safe_strerror(errno
), errno
);
1704 /* Make vty for configuration file. */
1705 file_vty
= vty_new();
1707 file_vty
->type
= VTY_FILE
;
1709 /* Config file header print. */
1710 vty_out(file_vty
, "!\n! Zebra configuration saved from vty\n! ");
1711 vty_time_print(file_vty
, 1);
1712 vty_out(file_vty
, "!\n");
1713 vty_write_config(file_vty
);
1714 vty_close(file_vty
);
1716 if (stat(config_file
, &conf_stat
) >= 0) {
1717 if (unlink(config_file_sav
) != 0)
1718 if (errno
!= ENOENT
) {
1720 "Can't unlink backup configuration file %s.\n",
1724 if (link(config_file
, config_file_sav
) != 0) {
1726 "Can't backup old configuration file %s.\n",
1733 if (rename(config_file_tmp
, config_file
) != 0) {
1734 vty_out(vty
, "Can't save configuration file %s.\n",
1741 vty_out(vty
, "Configuration saved to %s\n", config_file
);
1745 if (ret
!= CMD_SUCCESS
)
1746 unlink(config_file_tmp
);
1749 XFREE(MTYPE_TMP
, config_file_tmp
);
1750 XFREE(MTYPE_TMP
, config_file_sav
);
1754 /* Write current configuration into file. */
1756 DEFUN (config_write
,
1758 "write [<file|memory|terminal>]",
1759 "Write running configuration to memory, network, or terminal\n"
1760 "Write to configuration file\n"
1761 "Write configuration currently in memory\n"
1762 "Write configuration to terminal\n")
1764 const int idx_type
= 1;
1766 // if command was 'write terminal' or 'write memory'
1767 if (argc
== 2 && (!strcmp(argv
[idx_type
]->text
, "terminal"))) {
1768 return vty_write_config(vty
);
1771 return file_write_config(vty
);
1774 /* ALIAS_FIXME for 'write <terminal|memory>' */
1775 DEFUN (show_running_config
,
1776 show_running_config_cmd
,
1777 "show running-config",
1779 "running configuration (same as write terminal)\n")
1781 return vty_write_config(vty
);
1784 /* ALIAS_FIXME for 'write file' */
1785 DEFUN (copy_runningconf_startupconf
,
1786 copy_runningconf_startupconf_cmd
,
1787 "copy running-config startup-config",
1788 "Copy configuration\n"
1789 "Copy running config to... \n"
1790 "Copy running config to startup config (same as write file/memory)\n")
1792 return file_write_config(vty
);
1796 /* Write startup configuration into the terminal. */
1797 DEFUN (show_startup_config
,
1798 show_startup_config_cmd
,
1799 "show startup-config",
1801 "Contents of startup configuration\n")
1808 if (host
.config
== NULL
)
1811 confp
= fopen(host
.config
, "r");
1812 if (confp
== NULL
) {
1813 vty_out(vty
, "Can't open configuration file [%s] due to '%s'\n",
1814 host
.config
, safe_strerror(errno
));
1818 while (fgets(buf
, BUFSIZ
, confp
)) {
1821 while (*cp
!= '\r' && *cp
!= '\n' && *cp
!= '\0')
1825 vty_out(vty
, "%s\n", buf
);
1833 int cmd_domainname_set(const char *domainname
)
1835 XFREE(MTYPE_HOST
, host
.domainname
);
1836 host
.domainname
= domainname
? XSTRDUP(MTYPE_HOST
, domainname
) : NULL
;
1840 /* Hostname configuration */
1841 DEFUN(config_domainname
,
1844 "Set system's domain name\n"
1845 "This system's domain name\n")
1847 struct cmd_token
*word
= argv
[1];
1849 if (!isalpha((unsigned char)word
->arg
[0])) {
1850 vty_out(vty
, "Please specify string starting with alphabet\n");
1851 return CMD_WARNING_CONFIG_FAILED
;
1854 return cmd_domainname_set(word
->arg
);
1857 DEFUN(config_no_domainname
,
1859 "no domainname [DOMAINNAME]",
1861 "Reset system's domain name\n"
1862 "domain name of this router\n")
1864 return cmd_domainname_set(NULL
);
1867 int cmd_hostname_set(const char *hostname
)
1869 XFREE(MTYPE_HOST
, host
.name
);
1870 host
.name
= hostname
? XSTRDUP(MTYPE_HOST
, hostname
) : NULL
;
1874 /* Hostname configuration */
1875 DEFUN (config_hostname
,
1878 "Set system's network name\n"
1879 "This system's network name\n")
1881 struct cmd_token
*word
= argv
[1];
1883 if (!isalnum((unsigned char)word
->arg
[0])) {
1885 "Please specify string starting with alphabet or number\n");
1886 return CMD_WARNING_CONFIG_FAILED
;
1889 /* With reference to RFC 1123 Section 2.1 */
1890 if (strlen(word
->arg
) > HOSTNAME_LEN
) {
1891 vty_out(vty
, "Hostname length should be less than %d chars\n",
1893 return CMD_WARNING_CONFIG_FAILED
;
1896 return cmd_hostname_set(word
->arg
);
1899 DEFUN (config_no_hostname
,
1901 "no hostname [HOSTNAME]",
1903 "Reset system's network name\n"
1904 "Host name of this router\n")
1906 return cmd_hostname_set(NULL
);
1909 /* VTY interface password set. */
1910 DEFUN (config_password
,
1912 "password [(8-8)] WORD",
1913 "Modify the terminal connection password\n"
1914 "Specifies a HIDDEN password will follow\n"
1915 "The password string\n")
1919 if (argc
== 3) // '8' was specified
1922 XFREE(MTYPE_HOST
, host
.password
);
1923 host
.password
= NULL
;
1924 if (host
.password_encrypt
)
1925 XFREE(MTYPE_HOST
, host
.password_encrypt
);
1926 host
.password_encrypt
=
1927 XSTRDUP(MTYPE_HOST
, argv
[idx_word
]->arg
);
1931 if (!isalnum((unsigned char)argv
[idx_8
]->arg
[0])) {
1933 "Please specify string starting with alphanumeric\n");
1934 return CMD_WARNING_CONFIG_FAILED
;
1938 XFREE(MTYPE_HOST
, host
.password
);
1939 host
.password
= NULL
;
1942 if (host
.password_encrypt
)
1943 XFREE(MTYPE_HOST
, host
.password_encrypt
);
1944 host
.password_encrypt
=
1945 XSTRDUP(MTYPE_HOST
, zencrypt(argv
[idx_8
]->arg
));
1947 host
.password
= XSTRDUP(MTYPE_HOST
, argv
[idx_8
]->arg
);
1952 /* VTY interface password delete. */
1953 DEFUN (no_config_password
,
1957 "Modify the terminal connection password\n")
1959 bool warned
= false;
1961 if (host
.password
) {
1962 if (!vty_shell_serv(vty
)) {
1963 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
1966 XFREE(MTYPE_HOST
, host
.password
);
1968 host
.password
= NULL
;
1970 if (host
.password_encrypt
) {
1971 if (!warned
&& !vty_shell_serv(vty
))
1972 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
1973 XFREE(MTYPE_HOST
, host
.password_encrypt
);
1975 host
.password_encrypt
= NULL
;
1980 /* VTY enable password set. */
1981 DEFUN (config_enable_password
,
1982 enable_password_cmd
,
1983 "enable password [(8-8)] WORD",
1984 "Modify enable password parameters\n"
1985 "Assign the privileged level password\n"
1986 "Specifies a HIDDEN password will follow\n"
1987 "The HIDDEN 'enable' password string\n")
1992 /* Crypt type is specified. */
1994 if (argv
[idx_8
]->arg
[0] == '8') {
1996 XFREE(MTYPE_HOST
, host
.enable
);
1999 if (host
.enable_encrypt
)
2000 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2001 host
.enable_encrypt
=
2002 XSTRDUP(MTYPE_HOST
, argv
[idx_word
]->arg
);
2006 vty_out(vty
, "Unknown encryption type.\n");
2007 return CMD_WARNING_CONFIG_FAILED
;
2011 if (!isalnum((unsigned char)argv
[idx_8
]->arg
[0])) {
2013 "Please specify string starting with alphanumeric\n");
2014 return CMD_WARNING_CONFIG_FAILED
;
2018 XFREE(MTYPE_HOST
, host
.enable
);
2021 /* Plain password input. */
2023 if (host
.enable_encrypt
)
2024 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2025 host
.enable_encrypt
=
2026 XSTRDUP(MTYPE_HOST
, zencrypt(argv
[idx_8
]->arg
));
2028 host
.enable
= XSTRDUP(MTYPE_HOST
, argv
[idx_8
]->arg
);
2033 /* VTY enable password delete. */
2034 DEFUN (no_config_enable_password
,
2035 no_enable_password_cmd
,
2036 "no enable password",
2038 "Modify enable password parameters\n"
2039 "Assign the privileged level password\n")
2041 bool warned
= false;
2044 if (!vty_shell_serv(vty
)) {
2045 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
2048 XFREE(MTYPE_HOST
, host
.enable
);
2052 if (host
.enable_encrypt
) {
2053 if (!warned
&& !vty_shell_serv(vty
))
2054 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
2055 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2057 host
.enable_encrypt
= NULL
;
2062 DEFUN (service_password_encrypt
,
2063 service_password_encrypt_cmd
,
2064 "service password-encryption",
2065 "Set up miscellaneous service\n"
2066 "Enable encrypted passwords\n")
2073 if (host
.password
) {
2074 if (host
.password_encrypt
)
2075 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2076 host
.password_encrypt
=
2077 XSTRDUP(MTYPE_HOST
, zencrypt(host
.password
));
2080 if (host
.enable_encrypt
)
2081 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2082 host
.enable_encrypt
=
2083 XSTRDUP(MTYPE_HOST
, zencrypt(host
.enable
));
2089 DEFUN (no_service_password_encrypt
,
2090 no_service_password_encrypt_cmd
,
2091 "no service password-encryption",
2093 "Set up miscellaneous service\n"
2094 "Enable encrypted passwords\n")
2101 if (host
.password_encrypt
)
2102 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2103 host
.password_encrypt
= NULL
;
2105 if (host
.enable_encrypt
)
2106 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2107 host
.enable_encrypt
= NULL
;
2112 DEFUN (config_terminal_length
,
2113 config_terminal_length_cmd
,
2114 "terminal length (0-512)",
2115 "Set terminal line parameters\n"
2116 "Set number of lines on a screen\n"
2117 "Number of lines on screen (0 for no pausing)\n")
2121 vty
->lines
= atoi(argv
[idx_number
]->arg
);
2126 DEFUN (config_terminal_no_length
,
2127 config_terminal_no_length_cmd
,
2128 "terminal no length",
2129 "Set terminal line parameters\n"
2131 "Set number of lines on a screen\n")
2137 DEFUN (service_terminal_length
,
2138 service_terminal_length_cmd
,
2139 "service terminal-length (0-512)",
2140 "Set up miscellaneous service\n"
2141 "System wide terminal length configuration\n"
2142 "Number of lines of VTY (0 means no line control)\n")
2146 host
.lines
= atoi(argv
[idx_number
]->arg
);
2151 DEFUN (no_service_terminal_length
,
2152 no_service_terminal_length_cmd
,
2153 "no service terminal-length [(0-512)]",
2155 "Set up miscellaneous service\n"
2156 "System wide terminal length configuration\n"
2157 "Number of lines of VTY (0 means no line control)\n")
2163 DEFUN_HIDDEN (do_echo
,
2166 "Echo a message back to the vty\n"
2167 "The message to echo\n")
2171 vty_out(vty
, "%s\n",
2172 ((message
= argv_concat(argv
, argc
, 1)) ? message
: ""));
2174 XFREE(MTYPE_TMP
, message
);
2178 DEFUN (config_logmsg
,
2180 "logmsg <emergencies|alerts|critical|errors|warnings|notifications|informational|debugging> MESSAGE...",
2181 "Send a message to enabled logging destinations\n"
2183 "The message to send\n")
2185 int idx_log_level
= 1;
2186 int idx_message
= 2;
2190 level
= log_level_match(argv
[idx_log_level
]->arg
);
2191 if (level
== ZLOG_DISABLED
)
2192 return CMD_ERR_NO_MATCH
;
2195 ((message
= argv_concat(argv
, argc
, idx_message
)) ? message
: ""));
2197 XFREE(MTYPE_TMP
, message
);
2202 DEFUN (debug_memstats
,
2204 "[no] debug memstats-at-exit",
2207 "Print memory type statistics at exit\n")
2209 debug_memstats_at_exit
= !!strcmp(argv
[0]->text
, "no");
2213 int cmd_banner_motd_file(const char *file
)
2215 int success
= CMD_SUCCESS
;
2220 rpath
= realpath(file
, p
);
2222 return CMD_ERR_NO_FILE
;
2223 in
= strstr(rpath
, SYSCONFDIR
);
2225 XFREE(MTYPE_HOST
, host
.motdfile
);
2226 host
.motdfile
= XSTRDUP(MTYPE_HOST
, file
);
2228 success
= CMD_WARNING_CONFIG_FAILED
;
2233 void cmd_banner_motd_line(const char *line
)
2235 XFREE(MTYPE_HOST
, host
.motd
);
2236 host
.motd
= XSTRDUP(MTYPE_HOST
, line
);
2239 DEFUN (banner_motd_file
,
2240 banner_motd_file_cmd
,
2241 "banner motd file FILE",
2244 "Banner from a file\n"
2248 const char *filename
= argv
[idx_file
]->arg
;
2249 int cmd
= cmd_banner_motd_file(filename
);
2251 if (cmd
== CMD_ERR_NO_FILE
)
2252 vty_out(vty
, "%s does not exist\n", filename
);
2253 else if (cmd
== CMD_WARNING_CONFIG_FAILED
)
2254 vty_out(vty
, "%s must be in %s\n", filename
, SYSCONFDIR
);
2259 DEFUN (banner_motd_line
,
2260 banner_motd_line_cmd
,
2261 "banner motd line LINE...",
2264 "Banner from an input\n"
2270 argv_find(argv
, argc
, "LINE", &idx
);
2271 motd
= argv_concat(argv
, argc
, idx
);
2273 cmd_banner_motd_line(motd
);
2274 XFREE(MTYPE_TMP
, motd
);
2279 DEFUN (banner_motd_default
,
2280 banner_motd_default_cmd
,
2281 "banner motd default",
2282 "Set banner string\n"
2283 "Strings for motd\n"
2286 cmd_banner_motd_line(FRR_DEFAULT_MOTD
);
2290 DEFUN (no_banner_motd
,
2294 "Set banner string\n"
2295 "Strings for motd\n")
2299 XFREE(MTYPE_HOST
, host
.motdfile
);
2300 host
.motdfile
= NULL
;
2304 DEFUN(allow_reserved_ranges
, allow_reserved_ranges_cmd
, "allow-reserved-ranges",
2305 "Allow using IPv4 (Class E) reserved IP space\n")
2307 host
.allow_reserved_ranges
= true;
2311 DEFUN(no_allow_reserved_ranges
, no_allow_reserved_ranges_cmd
,
2312 "no allow-reserved-ranges",
2313 NO_STR
"Allow using IPv4 (Class E) reserved IP space\n")
2315 host
.allow_reserved_ranges
= false;
2319 int cmd_find_cmds(struct vty
*vty
, struct cmd_token
**argv
, int argc
)
2321 const struct cmd_node
*node
;
2322 const struct cmd_element
*cli
;
2327 char *pattern
= argv_concat(argv
, argc
, 1);
2328 int cr
= regcomp(&exp
, pattern
, REG_NOSUB
| REG_EXTENDED
);
2329 XFREE(MTYPE_TMP
, pattern
);
2334 vty_out(vty
, "%% Invalid {...} expression\n");
2337 vty_out(vty
, "%% Bad repetition operator\n");
2340 vty_out(vty
, "%% Regex syntax error\n");
2343 vty_out(vty
, "%% Invalid collating element\n");
2346 vty_out(vty
, "%% Invalid character class name\n");
2350 "%% Regex ended with escape character (\\)\n");
2354 "%% Invalid number in \\digit construction\n");
2357 vty_out(vty
, "%% Unbalanced square brackets\n");
2360 vty_out(vty
, "%% Unbalanced parentheses\n");
2363 vty_out(vty
, "%% Unbalanced braces\n");
2367 "%% Invalid endpoint in range expression\n");
2370 vty_out(vty
, "%% Failed to compile (out of memory)\n");
2378 for (unsigned int i
= 0; i
< vector_active(cmdvec
); i
++) {
2379 node
= vector_slot(cmdvec
, i
);
2382 clis
= node
->cmd_vector
;
2383 for (unsigned int j
= 0; j
< vector_active(clis
); j
++) {
2384 cli
= vector_slot(clis
, j
);
2386 if (regexec(&exp
, cli
->string
, 0, NULL
, 0) == 0) {
2387 vty_out(vty
, " (%s) ", node
->name
);
2388 print_cmd(vty
, cli
->string
);
2401 "Find CLI command matching a regular expression\n"
2402 "Search pattern (POSIX regex)\n")
2404 return cmd_find_cmds(vty
, argv
, argc
);
2407 #if defined(DEV_BUILD) && defined(HAVE_SCRIPTING)
2408 DEFUN(script
, script_cmd
, "script SCRIPT FUNCTION",
2409 "Test command - execute a function in a script\n"
2410 "Script name (same as filename in /etc/frr/scripts/)\n"
2411 "Function name (in the script)\n")
2415 (void)str2prefix("1.2.3.4/24", &p
);
2416 struct frrscript
*fs
= frrscript_new(argv
[1]->arg
);
2418 if (frrscript_load(fs
, argv
[2]->arg
, NULL
)) {
2420 "/etc/frr/scripts/%s.lua or function '%s' not found\n",
2421 argv
[1]->arg
, argv
[2]->arg
);
2424 int ret
= frrscript_call(fs
, argv
[2]->arg
, ("p", &p
));
2426 prefix2str(&p
, buf
, sizeof(buf
));
2427 vty_out(vty
, "p: %s\n", buf
);
2428 vty_out(vty
, "Script result: %d\n", ret
);
2430 frrscript_delete(fs
);
2436 /* Set config filename. Called from vty.c */
2437 void host_config_set(const char *filename
)
2439 XFREE(MTYPE_HOST
, host
.config
);
2440 host
.config
= XSTRDUP(MTYPE_HOST
, filename
);
2443 const char *host_config_get(void)
2448 void cmd_show_lib_debugs(struct vty
*vty
)
2450 route_map_show_debug(vty
);
2451 mgmt_debug_be_client_show_debug(vty
);
2452 mgmt_debug_fe_client_show_debug(vty
);
2455 void install_default(enum node_type node
)
2457 _install_element(node
, &config_exit_cmd
);
2458 _install_element(node
, &config_quit_cmd
);
2459 _install_element(node
, &config_end_cmd
);
2460 _install_element(node
, &config_help_cmd
);
2461 _install_element(node
, &config_list_cmd
);
2462 _install_element(node
, &show_cli_graph_cmd
);
2463 _install_element(node
, &find_cmd
);
2465 _install_element(node
, &config_write_cmd
);
2466 _install_element(node
, &show_running_config_cmd
);
2468 _install_element(node
, &autocomplete_cmd
);
2470 nb_cli_install_default(node
);
2473 /* Initialize command interface. Install basic nodes and commands.
2475 * terminal = 0 -- vtysh / no logging, no config control
2476 * terminal = 1 -- normal daemon
2477 * terminal = -1 -- watchfrr / no logging, but minimal config control */
2478 void cmd_init(int terminal
)
2480 struct utsname names
;
2485 /* register command preprocessors */
2486 hook_register(cmd_execute
, handle_pipe_action
);
2487 hook_register(cmd_execute_done
, handle_pipe_action_done
);
2489 varhandlers
= list_new();
2491 /* Allocate initial top vector of commands. */
2492 cmdvec
= vector_init(VECTOR_MIN_SIZE
);
2494 /* Default host value settings. */
2495 host
.name
= XSTRDUP(MTYPE_HOST
, names
.nodename
);
2496 host
.system
= XSTRDUP(MTYPE_HOST
, names
.sysname
);
2497 host
.release
= XSTRDUP(MTYPE_HOST
, names
.release
);
2498 host
.version
= XSTRDUP(MTYPE_HOST
, names
.version
);
2500 #ifdef HAVE_STRUCT_UTSNAME_DOMAINNAME
2501 if ((strcmp(names
.domainname
, "(none)") == 0))
2502 host
.domainname
= NULL
;
2504 host
.domainname
= XSTRDUP(MTYPE_HOST
, names
.domainname
);
2506 host
.domainname
= NULL
;
2508 host
.password
= NULL
;
2511 host
.noconfig
= (terminal
< 0);
2513 cmd_banner_motd_line(FRR_DEFAULT_MOTD
);
2514 host
.motdfile
= NULL
;
2515 host
.allow_reserved_ranges
= false;
2517 /* Install top nodes. */
2518 install_node(&view_node
);
2519 install_node(&enable_node
);
2520 install_node(&auth_node
);
2521 install_node(&auth_enable_node
);
2522 install_node(&config_node
);
2524 /* Each node's basic commands. */
2525 install_element(VIEW_NODE
, &show_version_cmd
);
2526 install_element(ENABLE_NODE
, &show_startup_config_cmd
);
2529 install_element(ENABLE_NODE
, &debug_memstats_cmd
);
2531 install_element(VIEW_NODE
, &config_list_cmd
);
2532 install_element(VIEW_NODE
, &config_exit_cmd
);
2533 install_element(VIEW_NODE
, &config_quit_cmd
);
2534 install_element(VIEW_NODE
, &config_help_cmd
);
2535 install_element(VIEW_NODE
, &config_enable_cmd
);
2536 install_element(VIEW_NODE
, &config_terminal_length_cmd
);
2537 install_element(VIEW_NODE
, &config_terminal_no_length_cmd
);
2538 install_element(VIEW_NODE
, &show_commandtree_cmd
);
2539 install_element(VIEW_NODE
, &echo_cmd
);
2540 install_element(VIEW_NODE
, &autocomplete_cmd
);
2541 install_element(VIEW_NODE
, &find_cmd
);
2542 #if defined(DEV_BUILD) && defined(HAVE_SCRIPTING)
2543 install_element(VIEW_NODE
, &script_cmd
);
2547 install_element(ENABLE_NODE
, &config_end_cmd
);
2548 install_element(ENABLE_NODE
, &config_disable_cmd
);
2549 install_element(ENABLE_NODE
, &config_terminal_cmd
);
2550 install_element(ENABLE_NODE
, ©_runningconf_startupconf_cmd
);
2551 install_element(ENABLE_NODE
, &config_write_cmd
);
2552 install_element(ENABLE_NODE
, &show_running_config_cmd
);
2553 install_element(ENABLE_NODE
, &config_logmsg_cmd
);
2555 install_default(CONFIG_NODE
);
2558 workqueue_cmd_init();
2562 install_element(CONFIG_NODE
, &hostname_cmd
);
2563 install_element(CONFIG_NODE
, &no_hostname_cmd
);
2564 install_element(CONFIG_NODE
, &domainname_cmd
);
2565 install_element(CONFIG_NODE
, &no_domainname_cmd
);
2570 install_element(CONFIG_NODE
, &debug_memstats_cmd
);
2572 install_element(CONFIG_NODE
, &password_cmd
);
2573 install_element(CONFIG_NODE
, &no_password_cmd
);
2574 install_element(CONFIG_NODE
, &enable_password_cmd
);
2575 install_element(CONFIG_NODE
, &no_enable_password_cmd
);
2577 install_element(CONFIG_NODE
, &service_password_encrypt_cmd
);
2578 install_element(CONFIG_NODE
, &no_service_password_encrypt_cmd
);
2579 install_element(CONFIG_NODE
, &banner_motd_default_cmd
);
2580 install_element(CONFIG_NODE
, &banner_motd_file_cmd
);
2581 install_element(CONFIG_NODE
, &banner_motd_line_cmd
);
2582 install_element(CONFIG_NODE
, &no_banner_motd_cmd
);
2583 install_element(CONFIG_NODE
, &service_terminal_length_cmd
);
2584 install_element(CONFIG_NODE
, &no_service_terminal_length_cmd
);
2585 install_element(CONFIG_NODE
, &allow_reserved_ranges_cmd
);
2586 install_element(CONFIG_NODE
, &no_allow_reserved_ranges_cmd
);
2589 vrf_install_commands();
2593 grammar_sandbox_init();
2597 void cmd_terminate(void)
2599 struct cmd_node
*cmd_node
;
2601 hook_unregister(cmd_execute
, handle_pipe_action
);
2602 hook_unregister(cmd_execute_done
, handle_pipe_action_done
);
2605 for (unsigned int i
= 0; i
< vector_active(cmdvec
); i
++)
2606 if ((cmd_node
= vector_slot(cmdvec
, i
)) != NULL
) {
2607 // deleting the graph delets the cmd_element as
2609 graph_delete_graph(cmd_node
->cmdgraph
);
2610 vector_free(cmd_node
->cmd_vector
);
2611 hash_clean_and_free(&cmd_node
->cmd_hash
, NULL
);
2614 vector_free(cmdvec
);
2618 XFREE(MTYPE_HOST
, host
.name
);
2619 XFREE(MTYPE_HOST
, host
.system
);
2620 XFREE(MTYPE_HOST
, host
.release
);
2621 XFREE(MTYPE_HOST
, host
.version
);
2622 XFREE(MTYPE_HOST
, host
.domainname
);
2623 XFREE(MTYPE_HOST
, host
.password
);
2624 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2625 XFREE(MTYPE_HOST
, host
.enable
);
2626 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2627 XFREE(MTYPE_HOST
, host
.motdfile
);
2628 XFREE(MTYPE_HOST
, host
.config
);
2629 XFREE(MTYPE_HOST
, host
.motd
);
2631 list_delete(&varhandlers
);