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"
51 DEFINE_MTYPE(LIB
, HOST
, "Host config")
52 DEFINE_MTYPE(LIB
, COMPLETION
, "Completion item")
59 /* clang-format off */
60 const struct message tokennames
[] = {
65 item(IPV4_PREFIX_TKN
),
67 item(IPV6_PREFIX_TKN
),
77 const char *node_names
[] = {
80 "auth enable", // AUTH_ENABLE_NODE,
81 "enable", // ENABLE_NODE,
82 "config", // CONFIG_NODE,
83 "debug", // DEBUG_NODE,
84 "vrf debug", // VRF_DEBUG_NODE,
85 "northbound debug", // NORTHBOUND_DEBUG_NODE,
86 "vnc debug", // DEBUG_VNC_NODE,
88 "keychain", // KEYCHAIN_NODE,
89 "keychain key", // KEYCHAIN_KEY_NODE,
90 "logical-router", // LOGICALROUTER_NODE,
91 "static ip", // IP_NODE,
93 "interface", // INTERFACE_NODE,
94 "nexthop-group", // NH_GROUP_NODE,
95 "zebra", // ZEBRA_NODE,
96 "table", // TABLE_NODE,
98 "ripng", // RIPNG_NODE,
99 "babel", // BABEL_NODE,
100 "eigrp", // EIGRP_NODE,
102 "bgp vpnv4", // BGP_VPNV4_NODE,
103 "bgp vpnv6", // BGP_VPNV6_NODE,
104 "bgp ipv4 unicast", // BGP_IPV4_NODE,
105 "bgp ipv4 multicast", // BGP_IPV4M_NODE,
106 "bgp ipv4 labeled unicast", // BGP_IPV4L_NODE,
107 "bgp ipv6", // BGP_IPV6_NODE,
108 "bgp ipv6 multicast", // BGP_IPV6M_NODE,
109 "bgp ipv6 labeled unicast", // BGP_IPV6L_NODE,
110 "bgp vrf policy", // BGP_VRF_POLICY_NODE,
111 "bgp vnc defaults", // BGP_VNC_DEFAULTS_NODE,
112 "bgp vnc nve", // BGP_VNC_NVE_GROUP_NODE,
113 "bgp vnc l2", // BGP_VNC_L2_GROUP_NODE,
114 "rfp defaults", // RFP_DEFAULTS_NODE,
115 "bgp evpn", // BGP_EVPN_NODE,
116 "ospf", // OSPF_NODE,
117 "ospf6", // OSPF6_NODE,
119 "ldp ipv4", // LDP_IPV4_NODE,
120 "ldp ipv6", // LDP_IPV6_NODE,
121 "ldp ipv4 interface", // LDP_IPV4_IFACE_NODE,
122 "ldp ipv6 interface", // LDP_IPV6_IFACE_NODE,
123 "ldp l2vpn", // LDP_L2VPN_NODE,
124 "ldp", // LDP_PSEUDOWIRE_NODE,
125 "isis", // ISIS_NODE,
126 "ipv4 access list", // ACCESS_NODE,
127 "ipv4 prefix list", // PREFIX_NODE,
128 "ipv6 access list", // ACCESS_IPV6_NODE,
129 "MAC access list", // ACCESS_MAC_NODE,
130 "ipv6 prefix list", // PREFIX_IPV6_NODE,
131 "as list", // AS_LIST_NODE,
132 "community list", // COMMUNITY_LIST_NODE,
133 "routemap", // RMAP_NODE,
134 "pbr-map", // PBRMAP_NODE,
135 "smux", // SMUX_NODE,
136 "dump", // DUMP_NODE,
137 "forwarding", // FORWARDING_NODE,
138 "protocol", // PROTOCOL_NODE,
139 "mpls", // MPLS_NODE,
142 "link-params", // LINK_PARAMS_NODE,
143 "bgp evpn vni", // BGP_EVPN_VNI_NODE,
145 "bgp ipv4 flowspec", /* BGP_FLOWSPECV4_NODE
147 "bgp ipv6 flowspec", /* BGP_FLOWSPECV6_NODE
149 "bfd", /* BFD_NODE */
150 "bfd peer", /* BFD_PEER_NODE */
151 "openfabric", // OPENFABRIC_NODE
153 /* clang-format on */
155 /* Command vector which includes some level of command lists. Normally
156 each daemon maintains each own cmdvec. */
157 vector cmdvec
= NULL
;
159 /* Host information structure. */
163 * Returns host.name if any, otherwise
164 * it returns the system hostname.
166 const char *cmd_hostname_get(void)
172 * Returns unix domainname
174 const char *cmd_domainname_get(void)
176 return host
.domainname
;
179 /* Standard command node structures. */
180 static struct cmd_node auth_node
= {
181 AUTH_NODE
, "Password: ",
184 static struct cmd_node view_node
= {
188 static struct cmd_node auth_enable_node
= {
189 AUTH_ENABLE_NODE
, "Password: ",
192 static struct cmd_node enable_node
= {
196 static struct cmd_node config_node
= {CONFIG_NODE
, "%s(config)# ", 1};
198 /* Default motd string. */
199 static const char *default_motd
= FRR_DEFAULT_MOTD
;
201 static const struct facility_map
{
205 } syslog_facilities
[] = {
206 {LOG_KERN
, "kern", 1},
207 {LOG_USER
, "user", 2},
208 {LOG_MAIL
, "mail", 1},
209 {LOG_DAEMON
, "daemon", 1},
210 {LOG_AUTH
, "auth", 1},
211 {LOG_SYSLOG
, "syslog", 1},
213 {LOG_NEWS
, "news", 1},
214 {LOG_UUCP
, "uucp", 2},
215 {LOG_CRON
, "cron", 1},
219 {LOG_LOCAL0
, "local0", 6},
220 {LOG_LOCAL1
, "local1", 6},
221 {LOG_LOCAL2
, "local2", 6},
222 {LOG_LOCAL3
, "local3", 6},
223 {LOG_LOCAL4
, "local4", 6},
224 {LOG_LOCAL5
, "local5", 6},
225 {LOG_LOCAL6
, "local6", 6},
226 {LOG_LOCAL7
, "local7", 6},
230 static const char *facility_name(int facility
)
232 const struct facility_map
*fm
;
234 for (fm
= syslog_facilities
; fm
->name
; fm
++)
235 if (fm
->facility
== facility
)
240 static int facility_match(const char *str
)
242 const struct facility_map
*fm
;
244 for (fm
= syslog_facilities
; fm
->name
; fm
++)
245 if (!strncmp(str
, fm
->name
, fm
->match
))
250 static int level_match(const char *s
)
254 for (level
= 0; zlog_priority
[level
] != NULL
; level
++)
255 if (!strncmp(s
, zlog_priority
[level
], 2))
257 return ZLOG_DISABLED
;
260 /* This is called from main when a daemon is invoked with -v or --version. */
261 void print_version(const char *progname
)
263 printf("%s version %s\n", progname
, FRR_VERSION
);
264 printf("%s\n", FRR_COPYRIGHT
);
265 printf("configured with:\n\t%s\n", FRR_CONFIG_ARGS
);
268 char *argv_concat(struct cmd_token
**argv
, int argc
, int shift
)
270 int cnt
= MAX(argc
- shift
, 0);
271 const char *argstr
[cnt
+ 1];
276 for (int i
= 0; i
< cnt
; i
++)
277 argstr
[i
] = argv
[i
+ shift
]->arg
;
279 return frrstr_join(argstr
, cnt
, " ");
282 vector
cmd_make_strvec(const char *string
)
287 const char *copy
= string
;
289 /* skip leading whitespace */
290 while (isspace((int)*copy
) && *copy
!= '\0')
293 /* if the entire string was whitespace or a comment, return */
294 if (*copy
== '\0' || *copy
== '!' || *copy
== '#')
297 vector result
= frrstr_split_vec(copy
, "\n\r\t ");
299 for (unsigned int i
= 0; i
< vector_active(result
); i
++) {
300 if (strlen(vector_slot(result
, i
)) == 0) {
301 XFREE(MTYPE_TMP
, vector_slot(result
, i
));
302 vector_unset(result
, i
);
306 vector_compact(result
);
311 void cmd_free_strvec(vector v
)
313 frrstr_strvec_free(v
);
317 * Convenience function for accessing argv data.
321 * @param text definition snippet of the desired token
322 * @param index the starting index, and where to store the
323 * index of the found token if it exists
324 * @return 1 if found, 0 otherwise
326 int argv_find(struct cmd_token
**argv
, int argc
, const char *text
, int *index
)
329 for (int i
= *index
; i
< argc
&& found
== 0; i
++)
330 if ((found
= strmatch(text
, argv
[i
]->text
)))
335 static unsigned int cmd_hash_key(void *p
)
337 int size
= sizeof(p
);
339 return jhash(p
, size
, 0);
342 static bool cmd_hash_cmp(const void *a
, const void *b
)
347 /* Install top node of command vector. */
348 void install_node(struct cmd_node
*node
, int (*func
)(struct vty
*))
350 vector_set_index(cmdvec
, node
->node
, node
);
352 node
->cmdgraph
= graph_new();
353 node
->cmd_vector
= vector_init(VECTOR_MIN_SIZE
);
355 struct cmd_token
*token
=
356 cmd_token_new(START_TKN
, CMD_ATTR_NORMAL
, NULL
, NULL
);
357 graph_new_node(node
->cmdgraph
, token
,
358 (void (*)(void *)) & cmd_token_del
);
359 node
->cmd_hash
= hash_create_size(16, cmd_hash_key
, cmd_hash_cmp
,
363 /* Return prompt character of specified node. */
364 const char *cmd_prompt(enum node_type node
)
366 struct cmd_node
*cnode
;
368 cnode
= vector_slot(cmdvec
, node
);
369 return cnode
->prompt
;
372 /* Install a command into a node. */
373 void install_element(enum node_type ntype
, struct cmd_element
*cmd
)
375 struct cmd_node
*cnode
;
377 /* cmd_init hasn't been called */
379 fprintf(stderr
, "%s called before cmd_init, breakage likely\n",
384 cnode
= vector_lookup(cmdvec
, ntype
);
389 "\tnode %d (%s) does not exist.\n"
390 "\tplease call install_node() before install_element()\n",
391 cmd
->name
, cmd
->string
, ntype
, node_names
[ntype
]);
395 if (hash_lookup(cnode
->cmd_hash
, cmd
) != NULL
) {
398 "\tnode %d (%s) already has this command installed.\n"
399 "\tduplicate install_element call?\n",
400 cmd
->name
, cmd
->string
, ntype
, node_names
[ntype
]);
404 assert(hash_get(cnode
->cmd_hash
, cmd
, hash_alloc_intern
));
406 struct graph
*graph
= graph_new();
407 struct cmd_token
*token
=
408 cmd_token_new(START_TKN
, CMD_ATTR_NORMAL
, NULL
, NULL
);
409 graph_new_node(graph
, token
, (void (*)(void *)) & cmd_token_del
);
411 cmd_graph_parse(graph
, cmd
);
412 cmd_graph_names(graph
);
413 cmd_graph_merge(cnode
->cmdgraph
, graph
, +1);
414 graph_delete_graph(graph
);
416 vector_set(cnode
->cmd_vector
, cmd
);
418 if (ntype
== VIEW_NODE
)
419 install_element(ENABLE_NODE
, cmd
);
422 void uninstall_element(enum node_type ntype
, struct cmd_element
*cmd
)
424 struct cmd_node
*cnode
;
426 /* cmd_init hasn't been called */
428 fprintf(stderr
, "%s called before cmd_init, breakage likely\n",
433 cnode
= vector_lookup(cmdvec
, ntype
);
438 "\tnode %d (%s) does not exist.\n"
439 "\tplease call install_node() before uninstall_element()\n",
440 cmd
->name
, cmd
->string
, ntype
, node_names
[ntype
]);
444 if (hash_release(cnode
->cmd_hash
, cmd
) == NULL
) {
447 "\tnode %d (%s) does not have this command installed.\n"
448 "\tduplicate uninstall_element call?\n",
449 cmd
->name
, cmd
->string
, ntype
, node_names
[ntype
]);
453 vector_unset_value(cnode
->cmd_vector
, cmd
);
455 struct graph
*graph
= graph_new();
456 struct cmd_token
*token
=
457 cmd_token_new(START_TKN
, CMD_ATTR_NORMAL
, NULL
, NULL
);
458 graph_new_node(graph
, token
, (void (*)(void *)) & cmd_token_del
);
460 cmd_graph_parse(graph
, cmd
);
461 cmd_graph_names(graph
);
462 cmd_graph_merge(cnode
->cmdgraph
, graph
, -1);
463 graph_delete_graph(graph
);
465 if (ntype
== VIEW_NODE
)
466 uninstall_element(ENABLE_NODE
, cmd
);
470 static const unsigned char itoa64
[] =
471 "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
473 static void to64(char *s
, long v
, int n
)
476 *s
++ = itoa64
[v
& 0x3f];
481 static char *zencrypt(const char *passwd
)
485 char *crypt(const char *, const char *);
487 gettimeofday(&tv
, 0);
489 to64(&salt
[0], random(), 3);
490 to64(&salt
[3], tv
.tv_usec
, 3);
493 return crypt(passwd
, salt
);
496 /* This function write configuration of this host. */
497 static int config_write_host(struct vty
*vty
)
499 if (cmd_hostname_get())
500 vty_out(vty
, "hostname %s\n", cmd_hostname_get());
502 if (cmd_domainname_get())
503 vty_out(vty
, "domainname %s\n", cmd_domainname_get());
505 /* The following are all configuration commands that are not sent to
506 * watchfrr. For instance watchfrr is hardcoded to log to syslog so
507 * we would always display 'log syslog informational' in the config
508 * which would cause other daemons to then switch to syslog when they
511 if (strcmp(zlog_default
->protoname
, "WATCHFRR")) {
513 if (host
.password_encrypt
)
514 vty_out(vty
, "password 8 %s\n",
515 host
.password_encrypt
);
516 if (host
.enable_encrypt
)
517 vty_out(vty
, "enable password 8 %s\n",
518 host
.enable_encrypt
);
521 vty_out(vty
, "password %s\n", host
.password
);
523 vty_out(vty
, "enable password %s\n",
528 && (zlog_default
->maxlvl
[ZLOG_DEST_FILE
]
530 vty_out(vty
, "log file %s", host
.logfile
);
531 if (zlog_default
->maxlvl
[ZLOG_DEST_FILE
]
532 != zlog_default
->default_lvl
)
535 [zlog_default
->maxlvl
540 if (zlog_default
->maxlvl
[ZLOG_DEST_STDOUT
] != ZLOG_DISABLED
) {
541 vty_out(vty
, "log stdout");
542 if (zlog_default
->maxlvl
[ZLOG_DEST_STDOUT
]
543 != zlog_default
->default_lvl
)
546 [zlog_default
->maxlvl
547 [ZLOG_DEST_STDOUT
]]);
551 if (zlog_default
->maxlvl
[ZLOG_DEST_MONITOR
] == ZLOG_DISABLED
)
552 vty_out(vty
, "no log monitor\n");
553 else if (zlog_default
->maxlvl
[ZLOG_DEST_MONITOR
]
554 != zlog_default
->default_lvl
)
555 vty_out(vty
, "log monitor %s\n",
556 zlog_priority
[zlog_default
->maxlvl
557 [ZLOG_DEST_MONITOR
]]);
559 if (zlog_default
->maxlvl
[ZLOG_DEST_SYSLOG
] != ZLOG_DISABLED
) {
560 vty_out(vty
, "log syslog");
561 if (zlog_default
->maxlvl
[ZLOG_DEST_SYSLOG
]
562 != zlog_default
->default_lvl
)
564 zlog_priority
[zlog_default
->maxlvl
565 [ZLOG_DEST_SYSLOG
]]);
569 if (zlog_default
->facility
!= LOG_DAEMON
)
570 vty_out(vty
, "log facility %s\n",
571 facility_name(zlog_default
->facility
));
573 if (zlog_default
->record_priority
== 1)
574 vty_out(vty
, "log record-priority\n");
576 if (zlog_default
->timestamp_precision
> 0)
577 vty_out(vty
, "log timestamp precision %d\n",
578 zlog_default
->timestamp_precision
);
581 vty_out(vty
, "service advanced-vty\n");
584 vty_out(vty
, "service password-encryption\n");
587 vty_out(vty
, "service terminal-length %d\n",
591 vty_out(vty
, "banner motd file %s\n", host
.motdfile
);
593 vty_out(vty
, "no banner motd\n");
596 if (debug_memstats_at_exit
)
597 vty_out(vty
, "!\ndebug memstats-at-exit\n");
602 /* Utility function for getting command graph. */
603 static struct graph
*cmd_node_graph(vector v
, enum node_type ntype
)
605 struct cmd_node
*cnode
= vector_slot(v
, ntype
);
606 return cnode
->cmdgraph
;
609 static int cmd_try_do_shortcut(enum node_type node
, char *first_word
)
611 if (first_word
!= NULL
&& node
!= AUTH_NODE
&& node
!= VIEW_NODE
612 && node
!= AUTH_ENABLE_NODE
&& 0 == strcmp("do", first_word
))
618 * Compare function for cmd_token.
619 * Used with qsort to sort command completions.
621 static int compare_completions(const void *fst
, const void *snd
)
623 const struct cmd_token
*first
= *(const struct cmd_token
* const *)fst
,
624 *secnd
= *(const struct cmd_token
* const *)snd
;
625 return strcmp(first
->text
, secnd
->text
);
629 * Takes a list of completions returned by command_complete,
630 * dedeuplicates them based on both text and description,
631 * sorts them, and returns them as a vector.
633 * @param completions linked list of cmd_token
634 * @return deduplicated and sorted vector with
636 vector
completions_to_vec(struct list
*completions
)
638 vector comps
= vector_init(VECTOR_MIN_SIZE
);
641 struct cmd_token
*token
, *cr
= NULL
;
642 unsigned int i
, exists
;
643 for (ALL_LIST_ELEMENTS_RO(completions
, ln
, token
)) {
644 if (token
->type
== END_TKN
&& (cr
= token
))
647 // linear search for token in completions vector
649 for (i
= 0; i
< vector_active(comps
) && !exists
; i
++) {
650 struct cmd_token
*curr
= vector_slot(comps
, i
);
652 exists
= !strcmp(curr
->text
, token
->text
)
653 && !strcmp(curr
->desc
, token
->desc
);
655 exists
= !strcmp(curr
->text
, token
->text
);
656 #endif /* VTYSH_DEBUG */
660 vector_set(comps
, token
);
664 qsort(comps
->index
, vector_active(comps
), sizeof(void *),
665 &compare_completions
);
667 // make <cr> the first element, if it is present
669 vector_set_index(comps
, vector_active(comps
), NULL
);
670 memmove(comps
->index
+ 1, comps
->index
,
671 (comps
->alloced
- 1) * sizeof(void *));
672 vector_set_index(comps
, 0, cr
);
678 * Generates a vector of cmd_token representing possible completions
679 * on the current input.
681 * @param vline the vectorized input line
682 * @param vty the vty with the node to match on
683 * @param status pointer to matcher status code
684 * @return vector of struct cmd_token * with possible completions
686 static vector
cmd_complete_command_real(vector vline
, struct vty
*vty
,
689 struct list
*completions
;
690 struct graph
*cmdgraph
= cmd_node_graph(cmdvec
, vty
->node
);
692 enum matcher_rv rv
= command_complete(cmdgraph
, vline
, &completions
);
694 if (MATCHER_ERROR(rv
)) {
695 *status
= CMD_ERR_NO_MATCH
;
699 vector comps
= completions_to_vec(completions
);
700 list_delete(&completions
);
702 // set status code appropriately
703 switch (vector_active(comps
)) {
705 *status
= CMD_ERR_NO_MATCH
;
708 *status
= CMD_COMPLETE_FULL_MATCH
;
711 *status
= CMD_COMPLETE_LIST_MATCH
;
717 vector
cmd_describe_command(vector vline
, struct vty
*vty
, int *status
)
721 if (cmd_try_do_shortcut(vty
->node
, vector_slot(vline
, 0))) {
722 enum node_type onode
;
723 int orig_xpath_index
;
724 vector shifted_vline
;
728 orig_xpath_index
= vty
->xpath_index
;
729 vty
->node
= ENABLE_NODE
;
730 vty
->xpath_index
= 0;
731 /* We can try it on enable node, cos' the vty is authenticated
734 shifted_vline
= vector_init(vector_count(vline
));
736 for (index
= 1; index
< vector_active(vline
); index
++) {
737 vector_set_index(shifted_vline
, index
- 1,
738 vector_lookup(vline
, index
));
741 ret
= cmd_complete_command_real(shifted_vline
, vty
, status
);
743 vector_free(shifted_vline
);
745 vty
->xpath_index
= orig_xpath_index
;
749 return cmd_complete_command_real(vline
, vty
, status
);
752 static struct list
*varhandlers
= NULL
;
754 void cmd_variable_complete(struct cmd_token
*token
, const char *arg
,
758 const struct cmd_variable_handler
*cvh
;
762 tmpcomps
= arg
? vector_init(VECTOR_MIN_SIZE
) : comps
;
764 for (ALL_LIST_ELEMENTS_RO(varhandlers
, ln
, cvh
)) {
765 if (cvh
->tokenname
&& strcmp(cvh
->tokenname
, token
->text
))
767 if (cvh
->varname
&& (!token
->varname
768 || strcmp(cvh
->varname
, token
->varname
)))
770 cvh
->completions(tmpcomps
, token
);
778 for (i
= vector_active(tmpcomps
); i
; i
--) {
779 char *item
= vector_slot(tmpcomps
, i
- 1);
780 if (strlen(item
) >= argsz
&& !strncmp(item
, arg
, argsz
))
781 vector_set(comps
, item
);
783 XFREE(MTYPE_COMPLETION
, item
);
785 vector_free(tmpcomps
);
788 #define AUTOCOMP_INDENT 5
790 char *cmd_variable_comp2str(vector comps
, unsigned short cols
)
793 char *buf
= XCALLOC(MTYPE_TMP
, bsz
);
794 int lc
= AUTOCOMP_INDENT
;
795 size_t cs
= AUTOCOMP_INDENT
;
797 snprintf(buf
, bsz
, "%*s", AUTOCOMP_INDENT
, "");
798 for (size_t j
= 0; j
< vector_active(comps
); j
++) {
799 char *item
= vector_slot(comps
, j
);
800 itemlen
= strlen(item
);
802 if (cs
+ itemlen
+ AUTOCOMP_INDENT
+ 3 >= bsz
)
803 buf
= XREALLOC(MTYPE_TMP
, buf
, (bsz
*= 2));
805 if (lc
+ itemlen
+ 1 >= cols
) {
806 cs
+= snprintf(&buf
[cs
], bsz
- cs
, "\n%*s",
807 AUTOCOMP_INDENT
, "");
808 lc
= AUTOCOMP_INDENT
;
811 size_t written
= snprintf(&buf
[cs
], bsz
- cs
, "%s ", item
);
814 XFREE(MTYPE_COMPLETION
, item
);
815 vector_set_index(comps
, j
, NULL
);
820 void cmd_variable_handler_register(const struct cmd_variable_handler
*cvh
)
825 for (; cvh
->completions
; cvh
++)
826 listnode_add(varhandlers
, (void *)cvh
);
829 DEFUN_HIDDEN (autocomplete
,
831 "autocomplete TYPE TEXT VARNAME",
832 "Autocompletion handler (internal, for vtysh)\n"
835 "cmd_token->varname\n")
837 struct cmd_token tok
;
838 vector comps
= vector_init(32);
841 memset(&tok
, 0, sizeof(tok
));
842 tok
.type
= atoi(argv
[1]->arg
);
843 tok
.text
= argv
[2]->arg
;
844 tok
.varname
= argv
[3]->arg
;
845 if (!strcmp(tok
.varname
, "-"))
848 cmd_variable_complete(&tok
, NULL
, comps
);
850 for (i
= 0; i
< vector_active(comps
); i
++) {
851 char *text
= vector_slot(comps
, i
);
852 vty_out(vty
, "%s\n", text
);
853 XFREE(MTYPE_COMPLETION
, text
);
861 * Generate possible tab-completions for the given input. This function only
862 * returns results that would result in a valid command if used as Readline
863 * completions (as is the case in vtysh). For instance, if the passed vline ends
864 * with '4.3.2', the strings 'A.B.C.D' and 'A.B.C.D/M' will _not_ be returned.
866 * @param vline vectorized input line
868 * @param status location to store matcher status code in
869 * @return set of valid strings for use with Readline as tab-completions.
872 char **cmd_complete_command(vector vline
, struct vty
*vty
, int *status
)
875 int original_node
= vty
->node
;
876 vector input_line
= vector_init(vector_count(vline
));
878 // if the first token is 'do' we'll want to execute the command in the
880 int do_shortcut
= cmd_try_do_shortcut(vty
->node
, vector_slot(vline
, 0));
881 vty
->node
= do_shortcut
? ENABLE_NODE
: original_node
;
883 // construct the input line we'll be matching on
884 unsigned int offset
= (do_shortcut
) ? 1 : 0;
885 for (unsigned index
= 0; index
+ offset
< vector_active(vline
); index
++)
886 vector_set_index(input_line
, index
,
887 vector_lookup(vline
, index
+ offset
));
889 // get token completions -- this is a copying operation
890 vector comps
= NULL
, initial_comps
;
891 initial_comps
= cmd_complete_command_real(input_line
, vty
, status
);
893 if (!MATCHER_ERROR(*status
)) {
894 assert(initial_comps
);
895 // filter out everything that is not suitable for a
897 comps
= vector_init(VECTOR_MIN_SIZE
);
898 for (unsigned int i
= 0; i
< vector_active(initial_comps
);
900 struct cmd_token
*token
= vector_slot(initial_comps
, i
);
901 if (token
->type
== WORD_TKN
)
902 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
,
904 else if (IS_VARYING_TOKEN(token
->type
)) {
905 const char *ref
= vector_lookup(
906 vline
, vector_active(vline
) - 1);
907 cmd_variable_complete(token
, ref
, comps
);
910 vector_free(initial_comps
);
912 // since we filtered results, we need to re-set status code
913 switch (vector_active(comps
)) {
915 *status
= CMD_ERR_NO_MATCH
;
918 *status
= CMD_COMPLETE_FULL_MATCH
;
921 *status
= CMD_COMPLETE_LIST_MATCH
;
924 // copy completions text into an array of char*
925 ret
= XMALLOC(MTYPE_TMP
,
926 (vector_active(comps
) + 1) * sizeof(char *));
928 for (i
= 0; i
< vector_active(comps
); i
++) {
929 ret
[i
] = vector_slot(comps
, i
);
931 // set the last element to NULL, because this array is used in
932 // a Readline completion_generator function which expects NULL
933 // as a sentinel value
937 } else if (initial_comps
)
938 vector_free(initial_comps
);
940 // comps should always be null here
943 // free the adjusted input line
944 vector_free(input_line
);
946 // reset vty->node to its original value
947 vty
->node
= original_node
;
952 /* return parent node */
953 /* MUST eventually converge on CONFIG_NODE */
954 enum node_type
node_parent(enum node_type node
)
958 assert(node
> CONFIG_NODE
);
963 case BGP_FLOWSPECV4_NODE
:
964 case BGP_FLOWSPECV6_NODE
:
965 case BGP_VRF_POLICY_NODE
:
966 case BGP_VNC_DEFAULTS_NODE
:
967 case BGP_VNC_NVE_GROUP_NODE
:
968 case BGP_VNC_L2_GROUP_NODE
:
978 case BGP_EVPN_VNI_NODE
:
981 case KEYCHAIN_KEY_NODE
:
984 case LINK_PARAMS_NODE
:
985 ret
= INTERFACE_NODE
;
991 case LDP_IPV4_IFACE_NODE
:
994 case LDP_IPV6_IFACE_NODE
:
997 case LDP_PSEUDOWIRE_NODE
:
998 ret
= LDP_L2VPN_NODE
;
1011 /* Execute command by argument vline vector. */
1012 static int cmd_execute_command_real(vector vline
, enum filter_type filter
,
1014 const struct cmd_element
**cmd
)
1016 struct list
*argv_list
;
1017 enum matcher_rv status
;
1018 const struct cmd_element
*matched_element
= NULL
;
1020 struct graph
*cmdgraph
= cmd_node_graph(cmdvec
, vty
->node
);
1021 status
= command_match(cmdgraph
, vline
, &argv_list
, &matched_element
);
1024 *cmd
= matched_element
;
1026 // if matcher error, return corresponding CMD_ERR
1027 if (MATCHER_ERROR(status
)) {
1029 list_delete(&argv_list
);
1031 case MATCHER_INCOMPLETE
:
1032 return CMD_ERR_INCOMPLETE
;
1033 case MATCHER_AMBIGUOUS
:
1034 return CMD_ERR_AMBIGUOUS
;
1036 return CMD_ERR_NO_MATCH
;
1040 // build argv array from argv list
1041 struct cmd_token
**argv
= XMALLOC(
1042 MTYPE_TMP
, argv_list
->count
* sizeof(struct cmd_token
*));
1043 struct listnode
*ln
;
1044 struct cmd_token
*token
;
1046 for (ALL_LIST_ELEMENTS_RO(argv_list
, ln
, token
))
1049 int argc
= argv_list
->count
;
1052 if (matched_element
->daemon
)
1053 ret
= CMD_SUCCESS_DAEMON
;
1055 ret
= matched_element
->func(matched_element
, vty
, argc
, argv
);
1057 // delete list and cmd_token's in it
1058 list_delete(&argv_list
);
1059 XFREE(MTYPE_TMP
, argv
);
1065 * Execute a given command, handling things like "do ..." and checking
1066 * whether the given command might apply at a parent node if doesn't
1067 * apply for the current node.
1069 * @param vline Command line input, vector of char* where each element is
1071 * @param vty The vty context in which the command should be executed.
1072 * @param cmd Pointer where the struct cmd_element of the matched command
1073 * will be stored, if any. May be set to NULL if this info is
1075 * @param vtysh If set != 0, don't lookup the command at parent nodes.
1076 * @return The status of the command that has been executed or an error code
1077 * as to why no command could be executed.
1079 int cmd_execute_command(vector vline
, struct vty
*vty
,
1080 const struct cmd_element
**cmd
, int vtysh
)
1082 int ret
, saved_ret
= 0;
1083 enum node_type onode
, try_node
;
1084 int orig_xpath_index
;
1086 onode
= try_node
= vty
->node
;
1087 orig_xpath_index
= vty
->xpath_index
;
1089 if (cmd_try_do_shortcut(vty
->node
, vector_slot(vline
, 0))) {
1090 vector shifted_vline
;
1093 vty
->node
= ENABLE_NODE
;
1094 vty
->xpath_index
= 0;
1095 /* We can try it on enable node, cos' the vty is authenticated
1098 shifted_vline
= vector_init(vector_count(vline
));
1100 for (index
= 1; index
< vector_active(vline
); index
++)
1101 vector_set_index(shifted_vline
, index
- 1,
1102 vector_lookup(vline
, index
));
1104 ret
= cmd_execute_command_real(shifted_vline
, FILTER_RELAXED
,
1107 vector_free(shifted_vline
);
1109 vty
->xpath_index
= orig_xpath_index
;
1114 cmd_execute_command_real(vline
, FILTER_RELAXED
, vty
, cmd
);
1119 if (ret
!= CMD_SUCCESS
&& ret
!= CMD_WARNING
1120 && ret
!= CMD_NOT_MY_INSTANCE
&& ret
!= CMD_WARNING_CONFIG_FAILED
) {
1121 /* This assumes all nodes above CONFIG_NODE are childs of
1123 while (vty
->node
> CONFIG_NODE
) {
1124 try_node
= node_parent(try_node
);
1125 vty
->node
= try_node
;
1126 if (vty
->xpath_index
> 0)
1128 ret
= cmd_execute_command_real(vline
, FILTER_RELAXED
,
1130 if (ret
== CMD_SUCCESS
|| ret
== CMD_WARNING
1131 || ret
== CMD_NOT_MY_INSTANCE
1132 || ret
== CMD_WARNING_CONFIG_FAILED
)
1135 /* no command succeeded, reset the vty to the original node */
1137 vty
->xpath_index
= orig_xpath_index
;
1140 /* return command status for original node */
1145 * Execute a given command, matching it strictly against the current node.
1146 * This mode is used when reading config files.
1148 * @param vline Command line input, vector of char* where each element is
1150 * @param vty The vty context in which the command should be executed.
1151 * @param cmd Pointer where the struct cmd_element* of the matched command
1152 * will be stored, if any. May be set to NULL if this info is
1154 * @return The status of the command that has been executed or an error code
1155 * as to why no command could be executed.
1157 int cmd_execute_command_strict(vector vline
, struct vty
*vty
,
1158 const struct cmd_element
**cmd
)
1160 return cmd_execute_command_real(vline
, FILTER_STRICT
, vty
, cmd
);
1164 * Hook for preprocessing command string before executing.
1166 * All subscribers are called with the raw command string that is to be
1167 * executed. If any changes are to be made, a new string should be allocated
1168 * with MTYPE_TMP and *cmd_out updated to point to this new string. The caller
1169 * is then responsible for freeing this string.
1171 * All processing functions must be mutually exclusive in their action, i.e. if
1172 * one subscriber decides to modify the command, all others must not modify it
1173 * when called. Feeding the output of one processing command into a subsequent
1174 * one is not supported.
1176 * This hook is intentionally internal to the command processing system.
1179 * The raw command string.
1182 * The result of any processing.
1184 DECLARE_HOOK(cmd_execute
,
1185 (struct vty
*vty
, const char *cmd_in
, char **cmd_out
),
1186 (vty
, cmd_in
, cmd_out
));
1187 DEFINE_HOOK(cmd_execute
, (struct vty
*vty
, const char *cmd_in
, char **cmd_out
),
1188 (vty
, cmd_in
, cmd_out
));
1190 /* Hook executed after a CLI command. */
1191 DECLARE_KOOH(cmd_execute_done
, (struct vty
*vty
, const char *cmd_exec
),
1193 DEFINE_KOOH(cmd_execute_done
, (struct vty
*vty
, const char *cmd_exec
),
1197 * cmd_execute hook subscriber to handle `|` actions.
1199 static int handle_pipe_action(struct vty
*vty
, const char *cmd_in
,
1203 char *orig
, *working
, *token
, *u
;
1204 char *pipe
= strstr(cmd_in
, "| ");
1209 /* duplicate string for processing purposes, not including pipe */
1210 orig
= working
= XSTRDUP(MTYPE_TMP
, pipe
+ 2);
1212 /* retrieve action */
1213 token
= strsep(&working
, " ");
1216 /* match result to known actions */
1217 if (strmatch(token
, "include")) {
1218 /* the remaining text should be a regexp */
1219 char *regexp
= working
;
1222 vty_out(vty
, "%% Need a regexp to filter with\n");
1226 bool succ
= vty_set_include(vty
, regexp
);
1229 vty_out(vty
, "%% Bad regexp '%s'\n", regexp
);
1232 *cmd_out
= XSTRDUP(MTYPE_TMP
, cmd_in
);
1236 vty_out(vty
, "%% Unknown action '%s'\n", token
);
1241 XFREE(MTYPE_TMP
, orig
);
1245 static int handle_pipe_action_done(struct vty
*vty
, const char *cmd_exec
)
1248 vty_set_include(vty
, NULL
);
1253 int cmd_execute(struct vty
*vty
, const char *cmd
,
1254 const struct cmd_element
**matched
, int vtysh
)
1257 char *cmd_out
= NULL
;
1258 const char *cmd_exec
;
1261 hook_call(cmd_execute
, vty
, cmd
, &cmd_out
);
1262 cmd_exec
= cmd_out
? (const char *)cmd_out
: cmd
;
1264 vline
= cmd_make_strvec(cmd_exec
);
1267 ret
= cmd_execute_command(vline
, vty
, matched
, vtysh
);
1268 cmd_free_strvec(vline
);
1273 hook_call(cmd_execute_done
, vty
, cmd_exec
);
1276 XFREE(MTYPE_TMP
, cmd_out
);
1283 * Parse one line of config, walking up the parse tree attempting to find a
1286 * @param vty The vty context in which the command should be executed.
1287 * @param cmd Pointer where the struct cmd_element* of the match command
1288 * will be stored, if any. May be set to NULL if this info is
1290 * @param use_daemon Boolean to control whether or not we match on
1291 * CMD_SUCCESS_DAEMON
1293 * @return The status of the command that has been executed or an error code
1294 * as to why no command could be executed.
1296 int command_config_read_one_line(struct vty
*vty
,
1297 const struct cmd_element
**cmd
,
1298 uint32_t line_num
, int use_daemon
)
1303 vline
= cmd_make_strvec(vty
->buf
);
1305 /* In case of comment line */
1309 /* Execute configuration command : this is strict match */
1310 ret
= cmd_execute_command_strict(vline
, vty
, cmd
);
1312 // Climb the tree and try the command again at each node
1313 if (!(use_daemon
&& ret
== CMD_SUCCESS_DAEMON
)
1314 && !(!use_daemon
&& ret
== CMD_ERR_NOTHING_TODO
)
1315 && ret
!= CMD_SUCCESS
&& ret
!= CMD_WARNING
1316 && ret
!= CMD_NOT_MY_INSTANCE
&& ret
!= CMD_WARNING_CONFIG_FAILED
1317 && vty
->node
!= CONFIG_NODE
) {
1318 int saved_node
= vty
->node
;
1319 int saved_xpath_index
= vty
->xpath_index
;
1321 while (!(use_daemon
&& ret
== CMD_SUCCESS_DAEMON
)
1322 && !(!use_daemon
&& ret
== CMD_ERR_NOTHING_TODO
)
1323 && ret
!= CMD_SUCCESS
&& ret
!= CMD_WARNING
1324 && vty
->node
> CONFIG_NODE
) {
1325 vty
->node
= node_parent(vty
->node
);
1326 if (vty
->xpath_index
> 0)
1328 ret
= cmd_execute_command_strict(vline
, vty
, cmd
);
1331 // If climbing the tree did not work then ignore the command and
1332 // stay at the same node
1333 if (!(use_daemon
&& ret
== CMD_SUCCESS_DAEMON
)
1334 && !(!use_daemon
&& ret
== CMD_ERR_NOTHING_TODO
)
1335 && ret
!= CMD_SUCCESS
&& ret
!= CMD_WARNING
) {
1336 vty
->node
= saved_node
;
1337 vty
->xpath_index
= saved_xpath_index
;
1341 if (ret
!= CMD_SUCCESS
&&
1342 ret
!= CMD_WARNING
&&
1343 ret
!= CMD_SUCCESS_DAEMON
) {
1344 struct vty_error
*ve
= XCALLOC(MTYPE_TMP
, sizeof(*ve
));
1346 memcpy(ve
->error_buf
, vty
->buf
, VTY_BUFSIZ
);
1347 ve
->line_num
= line_num
;
1349 vty
->error
= list_new();
1351 listnode_add(vty
->error
, ve
);
1354 cmd_free_strvec(vline
);
1359 /* Configuration make from file. */
1360 int config_from_file(struct vty
*vty
, FILE *fp
, unsigned int *line_num
)
1362 int ret
, error_ret
= 0;
1365 while (fgets(vty
->buf
, VTY_BUFSIZ
, fp
)) {
1368 ret
= command_config_read_one_line(vty
, NULL
, *line_num
, 0);
1370 if (ret
!= CMD_SUCCESS
&& ret
!= CMD_WARNING
1371 && ret
!= CMD_ERR_NOTHING_TODO
)
1382 /* Configuration from terminal */
1383 DEFUN (config_terminal
,
1384 config_terminal_cmd
,
1385 "configure terminal",
1386 "Configuration from vty interface\n"
1387 "Configuration terminal\n")
1389 if (vty_config_lock(vty
))
1390 vty
->node
= CONFIG_NODE
;
1392 vty_out(vty
, "VTY configuration is locked by other VTY\n");
1393 return CMD_WARNING_CONFIG_FAILED
;
1396 vty
->private_config
= false;
1397 vty
->candidate_config
= vty_shared_candidate_config
;
1398 if (frr_get_cli_mode() == FRR_CLI_TRANSACTIONAL
)
1399 vty
->candidate_config_base
= nb_config_dup(running_config
);
1404 /* Enable command */
1408 "Turn on privileged mode command\n")
1410 /* If enable password is NULL, change to ENABLE_NODE */
1411 if ((host
.enable
== NULL
&& host
.enable_encrypt
== NULL
)
1412 || vty
->type
== VTY_SHELL_SERV
)
1413 vty
->node
= ENABLE_NODE
;
1415 vty
->node
= AUTH_ENABLE_NODE
;
1420 /* Disable command */
1424 "Turn off privileged mode command\n")
1426 if (vty
->node
== ENABLE_NODE
)
1427 vty
->node
= VIEW_NODE
;
1431 /* Down vty node level. */
1435 "Exit current mode and down to previous mode\n")
1441 void cmd_exit(struct vty
*vty
)
1443 switch (vty
->node
) {
1449 vty
->status
= VTY_CLOSE
;
1452 vty
->node
= ENABLE_NODE
;
1453 vty_config_unlock(vty
);
1455 case INTERFACE_NODE
:
1457 case LOGICALROUTER_NODE
:
1469 case LDP_L2VPN_NODE
:
1471 case OPENFABRIC_NODE
:
1477 vty
->node
= CONFIG_NODE
;
1480 case BGP_IPV4M_NODE
:
1481 case BGP_IPV4L_NODE
:
1482 case BGP_VPNV4_NODE
:
1483 case BGP_VPNV6_NODE
:
1484 case BGP_FLOWSPECV4_NODE
:
1485 case BGP_FLOWSPECV6_NODE
:
1486 case BGP_VRF_POLICY_NODE
:
1487 case BGP_VNC_DEFAULTS_NODE
:
1488 case BGP_VNC_NVE_GROUP_NODE
:
1489 case BGP_VNC_L2_GROUP_NODE
:
1491 case BGP_IPV6M_NODE
:
1493 case BGP_IPV6L_NODE
:
1494 vty
->node
= BGP_NODE
;
1496 case BGP_EVPN_VNI_NODE
:
1497 vty
->node
= BGP_EVPN_NODE
;
1501 vty
->node
= LDP_NODE
;
1503 case LDP_IPV4_IFACE_NODE
:
1504 vty
->node
= LDP_IPV4_NODE
;
1506 case LDP_IPV6_IFACE_NODE
:
1507 vty
->node
= LDP_IPV6_NODE
;
1509 case LDP_PSEUDOWIRE_NODE
:
1510 vty
->node
= LDP_L2VPN_NODE
;
1512 case KEYCHAIN_KEY_NODE
:
1513 vty
->node
= KEYCHAIN_NODE
;
1515 case LINK_PARAMS_NODE
:
1516 vty
->node
= INTERFACE_NODE
;
1519 vty
->node
= BFD_NODE
;
1525 if (vty
->xpath_index
> 0)
1533 "Exit current mode and down to previous mode\n")
1535 return config_exit(self
, vty
, argc
, argv
);
1539 /* End of configuration. */
1543 "End current mode and change to enable mode.\n")
1545 switch (vty
->node
) {
1548 /* Nothing to do. */
1551 case INTERFACE_NODE
:
1553 case LOGICALROUTER_NODE
:
1562 case BGP_VRF_POLICY_NODE
:
1563 case BGP_VNC_DEFAULTS_NODE
:
1564 case BGP_VNC_NVE_GROUP_NODE
:
1565 case BGP_VNC_L2_GROUP_NODE
:
1566 case BGP_VPNV4_NODE
:
1567 case BGP_VPNV6_NODE
:
1568 case BGP_FLOWSPECV4_NODE
:
1569 case BGP_FLOWSPECV6_NODE
:
1571 case BGP_IPV4M_NODE
:
1572 case BGP_IPV4L_NODE
:
1574 case BGP_IPV6M_NODE
:
1576 case BGP_EVPN_VNI_NODE
:
1577 case BGP_IPV6L_NODE
:
1585 case LDP_IPV4_IFACE_NODE
:
1586 case LDP_IPV6_IFACE_NODE
:
1587 case LDP_L2VPN_NODE
:
1588 case LDP_PSEUDOWIRE_NODE
:
1590 case OPENFABRIC_NODE
:
1592 case KEYCHAIN_KEY_NODE
:
1594 case LINK_PARAMS_NODE
:
1597 vty_config_unlock(vty
);
1598 vty
->node
= ENABLE_NODE
;
1604 vty
->xpath_index
= 0;
1610 DEFUN (show_version
,
1614 "Displays zebra version\n")
1616 vty_out(vty
, "%s %s (%s).\n", FRR_FULL_NAME
, FRR_VERSION
,
1617 cmd_hostname_get() ? cmd_hostname_get() : "");
1618 vty_out(vty
, "%s%s\n", FRR_COPYRIGHT
, GIT_INFO
);
1619 vty_out(vty
, "configured with:\n %s\n", FRR_CONFIG_ARGS
);
1624 /* "Set" version ... ignore version tags */
1625 DEFUN (frr_version_defaults
,
1626 frr_version_defaults_cmd
,
1627 "frr <version|defaults> LINE...",
1628 "FRRouting global parameters\n"
1629 "version configuration was written by\n"
1630 "set of configuration defaults used\n"
1636 /* Help display function for all node. */
1640 "Description of the interactive help system\n")
1643 "Quagga VTY provides advanced help feature. When you need help,\n\
1644 anytime at the command line please press '?'.\n\
1646 If nothing matches, the help list will be empty and you must backup\n\
1647 until entering a '?' shows the available options.\n\
1648 Two styles of help are provided:\n\
1649 1. Full help is available when you are ready to enter a\n\
1650 command argument (e.g. 'show ?') and describes each possible\n\
1652 2. Partial help is provided when an abbreviated argument is entered\n\
1653 and you want to know what arguments match the input\n\
1654 (e.g. 'show me?'.)\n\n");
1658 static void permute(struct graph_node
*start
, struct vty
*vty
)
1660 static struct list
*position
= NULL
;
1662 position
= list_new();
1664 struct cmd_token
*stok
= start
->data
;
1665 struct graph_node
*gnn
;
1666 struct listnode
*ln
;
1669 listnode_add(position
, start
);
1670 for (unsigned int i
= 0; i
< vector_active(start
->to
); i
++) {
1671 struct graph_node
*gn
= vector_slot(start
->to
, i
);
1672 struct cmd_token
*tok
= gn
->data
;
1673 if (tok
->attr
== CMD_ATTR_HIDDEN
1674 || tok
->attr
== CMD_ATTR_DEPRECATED
)
1676 else if (tok
->type
== END_TKN
|| gn
== start
) {
1678 for (ALL_LIST_ELEMENTS_RO(position
, ln
, gnn
)) {
1679 struct cmd_token
*tt
= gnn
->data
;
1680 if (tt
->type
< SPECIAL_TKN
)
1681 vty_out(vty
, " %s", tt
->text
);
1684 vty_out(vty
, "...");
1688 if (stok
->type
== FORK_TKN
&& tok
->type
!= FORK_TKN
)
1689 for (ALL_LIST_ELEMENTS_RO(position
, ln
, gnn
))
1698 list_delete_node(position
, listtail(position
));
1701 int cmd_list_cmds(struct vty
*vty
, int do_permute
)
1703 struct cmd_node
*node
= vector_slot(cmdvec
, vty
->node
);
1706 permute(vector_slot(node
->cmdgraph
->nodes
, 0), vty
);
1708 /* loop over all commands at this node */
1709 struct cmd_element
*element
= NULL
;
1710 for (unsigned int i
= 0; i
< vector_active(node
->cmd_vector
);
1712 if ((element
= vector_slot(node
->cmd_vector
, i
))
1713 && element
->attr
!= CMD_ATTR_DEPRECATED
1714 && element
->attr
!= CMD_ATTR_HIDDEN
)
1715 vty_out(vty
, " %s\n", element
->string
);
1720 /* Help display function for all node. */
1723 "list [permutations]",
1724 "Print command list\n"
1725 "Print all possible command permutations\n")
1727 return cmd_list_cmds(vty
, argc
== 2);
1730 DEFUN (show_commandtree
,
1731 show_commandtree_cmd
,
1732 "show commandtree [permutations]",
1734 "Show command tree\n"
1735 "Permutations that we are interested in\n")
1737 return cmd_list_cmds(vty
, argc
== 3);
1740 DEFUN_HIDDEN(show_cli_graph
,
1745 "Dump current command space as DOT graph\n")
1747 struct cmd_node
*cn
= vector_slot(cmdvec
, vty
->node
);
1748 char *dot
= cmd_graph_dump_dot(cn
->cmdgraph
);
1750 vty_out(vty
, "%s\n", dot
);
1751 XFREE(MTYPE_TMP
, dot
);
1755 static int vty_write_config(struct vty
*vty
)
1758 struct cmd_node
*node
;
1763 if (vty
->type
== VTY_TERM
) {
1764 vty_out(vty
, "\nCurrent configuration:\n");
1765 vty_out(vty
, "!\n");
1768 vty_out(vty
, "frr version %s\n", FRR_VER_SHORT
);
1769 vty_out(vty
, "frr defaults %s\n", DFLT_NAME
);
1770 vty_out(vty
, "!\n");
1772 for (i
= 0; i
< vector_active(cmdvec
); i
++)
1773 if ((node
= vector_slot(cmdvec
, i
)) && node
->func
1774 && (node
->vtysh
|| vty
->type
!= VTY_SHELL
)) {
1775 if ((*node
->func
)(vty
))
1776 vty_out(vty
, "!\n");
1779 if (vty
->type
== VTY_TERM
) {
1780 vty_out(vty
, "end\n");
1786 static int file_write_config(struct vty
*vty
)
1789 char *config_file
, *slash
;
1790 char *config_file_tmp
= NULL
;
1791 char *config_file_sav
= NULL
;
1792 int ret
= CMD_WARNING
;
1793 struct vty
*file_vty
;
1794 struct stat conf_stat
;
1799 /* Check and see if we are operating under vtysh configuration */
1800 if (host
.config
== NULL
) {
1802 "Can't save to configuration file, using vtysh.\n");
1807 config_file
= host
.config
;
1810 #define O_DIRECTORY 0
1812 slash
= strrchr(config_file
, '/');
1814 char *config_dir
= XSTRDUP(MTYPE_TMP
, config_file
);
1815 config_dir
[slash
- config_file
] = '\0';
1816 dirfd
= open(config_dir
, O_DIRECTORY
| O_RDONLY
);
1817 XFREE(MTYPE_TMP
, config_dir
);
1819 dirfd
= open(".", O_DIRECTORY
| O_RDONLY
);
1820 /* if dirfd is invalid, directory sync fails, but we're still OK */
1822 config_file_sav
= XMALLOC(
1823 MTYPE_TMP
, strlen(config_file
) + strlen(CONF_BACKUP_EXT
) + 1);
1824 strcpy(config_file_sav
, config_file
);
1825 strcat(config_file_sav
, CONF_BACKUP_EXT
);
1828 config_file_tmp
= XMALLOC(MTYPE_TMP
, strlen(config_file
) + 8);
1829 sprintf(config_file_tmp
, "%s.XXXXXX", config_file
);
1831 /* Open file to configuration write. */
1832 fd
= mkstemp(config_file_tmp
);
1834 vty_out(vty
, "Can't open configuration file %s.\n",
1838 if (fchmod(fd
, CONFIGFILE_MASK
) != 0) {
1839 vty_out(vty
, "Can't chmod configuration file %s: %s (%d).\n",
1840 config_file_tmp
, safe_strerror(errno
), errno
);
1844 /* Make vty for configuration file. */
1845 file_vty
= vty_new();
1847 file_vty
->type
= VTY_FILE
;
1849 /* Config file header print. */
1850 vty_out(file_vty
, "!\n! Zebra configuration saved from vty\n! ");
1851 vty_time_print(file_vty
, 1);
1852 vty_out(file_vty
, "!\n");
1853 vty_write_config(file_vty
);
1854 vty_close(file_vty
);
1856 if (stat(config_file
, &conf_stat
) >= 0) {
1857 if (unlink(config_file_sav
) != 0)
1858 if (errno
!= ENOENT
) {
1860 "Can't unlink backup configuration file %s.\n",
1864 if (link(config_file
, config_file_sav
) != 0) {
1866 "Can't backup old configuration file %s.\n",
1873 if (rename(config_file_tmp
, config_file
) != 0) {
1874 vty_out(vty
, "Can't save configuration file %s.\n",
1881 vty_out(vty
, "Configuration saved to %s\n", config_file
);
1885 if (ret
!= CMD_SUCCESS
)
1886 unlink(config_file_tmp
);
1889 XFREE(MTYPE_TMP
, config_file_tmp
);
1890 XFREE(MTYPE_TMP
, config_file_sav
);
1894 /* Write current configuration into file. */
1896 DEFUN (config_write
,
1898 "write [<file|memory|terminal>]",
1899 "Write running configuration to memory, network, or terminal\n"
1900 "Write to configuration file\n"
1901 "Write configuration currently in memory\n"
1902 "Write configuration to terminal\n")
1904 const int idx_type
= 1;
1906 // if command was 'write terminal' or 'write memory'
1907 if (argc
== 2 && (!strcmp(argv
[idx_type
]->text
, "terminal"))) {
1908 return vty_write_config(vty
);
1911 return file_write_config(vty
);
1914 /* ALIAS_FIXME for 'write <terminal|memory>' */
1915 DEFUN (show_running_config
,
1916 show_running_config_cmd
,
1917 "show running-config",
1919 "running configuration (same as write terminal)\n")
1921 return vty_write_config(vty
);
1924 /* ALIAS_FIXME for 'write file' */
1925 DEFUN (copy_runningconf_startupconf
,
1926 copy_runningconf_startupconf_cmd
,
1927 "copy running-config startup-config",
1928 "Copy configuration\n"
1929 "Copy running config to... \n"
1930 "Copy running config to startup config (same as write file/memory)\n")
1932 return file_write_config(vty
);
1936 /* Write startup configuration into the terminal. */
1937 DEFUN (show_startup_config
,
1938 show_startup_config_cmd
,
1939 "show startup-config",
1941 "Contents of startup configuration\n")
1948 if (host
.config
== NULL
)
1951 confp
= fopen(host
.config
, "r");
1952 if (confp
== NULL
) {
1953 vty_out(vty
, "Can't open configuration file [%s] due to '%s'\n",
1954 host
.config
, safe_strerror(errno
));
1958 while (fgets(buf
, BUFSIZ
, confp
)) {
1961 while (*cp
!= '\r' && *cp
!= '\n' && *cp
!= '\0')
1965 vty_out(vty
, "%s\n", buf
);
1973 int cmd_domainname_set(const char *domainname
)
1975 XFREE(MTYPE_HOST
, host
.domainname
);
1976 host
.domainname
= domainname
? XSTRDUP(MTYPE_HOST
, domainname
) : NULL
;
1980 /* Hostname configuration */
1981 DEFUN(config_domainname
,
1984 "Set system's domain name\n"
1985 "This system's domain name\n")
1987 struct cmd_token
*word
= argv
[1];
1989 if (!isalpha((int)word
->arg
[0])) {
1990 vty_out(vty
, "Please specify string starting with alphabet\n");
1991 return CMD_WARNING_CONFIG_FAILED
;
1994 return cmd_domainname_set(word
->arg
);
1997 DEFUN(config_no_domainname
,
1999 "no domainname [DOMAINNAME]",
2001 "Reset system's domain name\n"
2002 "domain name of this router\n")
2004 return cmd_domainname_set(NULL
);
2007 int cmd_hostname_set(const char *hostname
)
2009 XFREE(MTYPE_HOST
, host
.name
);
2010 host
.name
= hostname
? XSTRDUP(MTYPE_HOST
, hostname
) : NULL
;
2014 /* Hostname configuration */
2015 DEFUN (config_hostname
,
2018 "Set system's network name\n"
2019 "This system's network name\n")
2021 struct cmd_token
*word
= argv
[1];
2023 if (!isalnum((int)word
->arg
[0])) {
2024 vty_out(vty
, "Please specify string starting with alphabet\n");
2025 return CMD_WARNING_CONFIG_FAILED
;
2028 return cmd_hostname_set(word
->arg
);
2031 DEFUN (config_no_hostname
,
2033 "no hostname [HOSTNAME]",
2035 "Reset system's network name\n"
2036 "Host name of this router\n")
2038 return cmd_hostname_set(NULL
);
2041 /* VTY interface password set. */
2042 DEFUN (config_password
,
2044 "password [(8-8)] WORD",
2045 "Modify the terminal connection password\n"
2046 "Specifies a HIDDEN password will follow\n"
2047 "The password string\n")
2051 if (argc
== 3) // '8' was specified
2054 XFREE(MTYPE_HOST
, host
.password
);
2055 host
.password
= NULL
;
2056 if (host
.password_encrypt
)
2057 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2058 host
.password_encrypt
=
2059 XSTRDUP(MTYPE_HOST
, argv
[idx_word
]->arg
);
2063 if (!isalnum((int)argv
[idx_8
]->arg
[0])) {
2065 "Please specify string starting with alphanumeric\n");
2066 return CMD_WARNING_CONFIG_FAILED
;
2070 XFREE(MTYPE_HOST
, host
.password
);
2071 host
.password
= NULL
;
2074 if (host
.password_encrypt
)
2075 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2076 host
.password_encrypt
=
2077 XSTRDUP(MTYPE_HOST
, zencrypt(argv
[idx_8
]->arg
));
2079 host
.password
= XSTRDUP(MTYPE_HOST
, argv
[idx_8
]->arg
);
2084 /* VTY interface password delete. */
2085 DEFUN (no_config_password
,
2089 "Modify the terminal connection password\n")
2091 bool warned
= false;
2093 if (host
.password
) {
2094 if (!vty_shell_serv(vty
)) {
2095 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
2098 XFREE(MTYPE_HOST
, host
.password
);
2100 host
.password
= NULL
;
2102 if (host
.password_encrypt
) {
2103 if (!warned
&& !vty_shell_serv(vty
))
2104 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
2105 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2107 host
.password_encrypt
= NULL
;
2112 /* VTY enable password set. */
2113 DEFUN (config_enable_password
,
2114 enable_password_cmd
,
2115 "enable password [(8-8)] WORD",
2116 "Modify enable password parameters\n"
2117 "Assign the privileged level password\n"
2118 "Specifies a HIDDEN password will follow\n"
2119 "The HIDDEN 'enable' password string\n")
2124 /* Crypt type is specified. */
2126 if (argv
[idx_8
]->arg
[0] == '8') {
2128 XFREE(MTYPE_HOST
, host
.enable
);
2131 if (host
.enable_encrypt
)
2132 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2133 host
.enable_encrypt
=
2134 XSTRDUP(MTYPE_HOST
, argv
[idx_word
]->arg
);
2138 vty_out(vty
, "Unknown encryption type.\n");
2139 return CMD_WARNING_CONFIG_FAILED
;
2143 if (!isalnum((int)argv
[idx_8
]->arg
[0])) {
2145 "Please specify string starting with alphanumeric\n");
2146 return CMD_WARNING_CONFIG_FAILED
;
2150 XFREE(MTYPE_HOST
, host
.enable
);
2153 /* Plain password input. */
2155 if (host
.enable_encrypt
)
2156 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2157 host
.enable_encrypt
=
2158 XSTRDUP(MTYPE_HOST
, zencrypt(argv
[idx_8
]->arg
));
2160 host
.enable
= XSTRDUP(MTYPE_HOST
, argv
[idx_8
]->arg
);
2165 /* VTY enable password delete. */
2166 DEFUN (no_config_enable_password
,
2167 no_enable_password_cmd
,
2168 "no enable password",
2170 "Modify enable password parameters\n"
2171 "Assign the privileged level password\n")
2173 bool warned
= false;
2176 if (!vty_shell_serv(vty
)) {
2177 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
2180 XFREE(MTYPE_HOST
, host
.enable
);
2184 if (host
.enable_encrypt
) {
2185 if (!warned
&& !vty_shell_serv(vty
))
2186 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
2187 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2189 host
.enable_encrypt
= NULL
;
2194 DEFUN (service_password_encrypt
,
2195 service_password_encrypt_cmd
,
2196 "service password-encryption",
2197 "Set up miscellaneous service\n"
2198 "Enable encrypted passwords\n")
2205 if (host
.password
) {
2206 if (host
.password_encrypt
)
2207 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2208 host
.password_encrypt
=
2209 XSTRDUP(MTYPE_HOST
, zencrypt(host
.password
));
2212 if (host
.enable_encrypt
)
2213 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2214 host
.enable_encrypt
=
2215 XSTRDUP(MTYPE_HOST
, zencrypt(host
.enable
));
2221 DEFUN (no_service_password_encrypt
,
2222 no_service_password_encrypt_cmd
,
2223 "no service password-encryption",
2225 "Set up miscellaneous service\n"
2226 "Enable encrypted passwords\n")
2233 if (host
.password_encrypt
)
2234 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2235 host
.password_encrypt
= NULL
;
2237 if (host
.enable_encrypt
)
2238 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2239 host
.enable_encrypt
= NULL
;
2244 DEFUN (config_terminal_length
,
2245 config_terminal_length_cmd
,
2246 "terminal length (0-512)",
2247 "Set terminal line parameters\n"
2248 "Set number of lines on a screen\n"
2249 "Number of lines on screen (0 for no pausing)\n")
2253 vty
->lines
= atoi(argv
[idx_number
]->arg
);
2258 DEFUN (config_terminal_no_length
,
2259 config_terminal_no_length_cmd
,
2260 "terminal no length",
2261 "Set terminal line parameters\n"
2263 "Set number of lines on a screen\n")
2269 DEFUN (service_terminal_length
,
2270 service_terminal_length_cmd
,
2271 "service terminal-length (0-512)",
2272 "Set up miscellaneous service\n"
2273 "System wide terminal length configuration\n"
2274 "Number of lines of VTY (0 means no line control)\n")
2278 host
.lines
= atoi(argv
[idx_number
]->arg
);
2283 DEFUN (no_service_terminal_length
,
2284 no_service_terminal_length_cmd
,
2285 "no service terminal-length [(0-512)]",
2287 "Set up miscellaneous service\n"
2288 "System wide terminal length configuration\n"
2289 "Number of lines of VTY (0 means no line control)\n")
2295 DEFUN_HIDDEN (do_echo
,
2298 "Echo a message back to the vty\n"
2299 "The message to echo\n")
2303 vty_out(vty
, "%s\n",
2304 ((message
= argv_concat(argv
, argc
, 1)) ? message
: ""));
2306 XFREE(MTYPE_TMP
, message
);
2310 DEFUN (config_logmsg
,
2312 "logmsg <emergencies|alerts|critical|errors|warnings|notifications|informational|debugging> MESSAGE...",
2313 "Send a message to enabled logging destinations\n"
2315 "The message to send\n")
2317 int idx_log_level
= 1;
2318 int idx_message
= 2;
2322 if ((level
= level_match(argv
[idx_log_level
]->arg
)) == ZLOG_DISABLED
)
2323 return CMD_ERR_NO_MATCH
;
2326 ((message
= argv_concat(argv
, argc
, idx_message
)) ? message
: ""));
2328 XFREE(MTYPE_TMP
, message
);
2333 DEFUN (show_logging
,
2337 "Show current logging configuration\n")
2339 struct zlog
*zl
= zlog_default
;
2341 vty_out(vty
, "Syslog logging: ");
2342 if (zl
->maxlvl
[ZLOG_DEST_SYSLOG
] == ZLOG_DISABLED
)
2343 vty_out(vty
, "disabled");
2345 vty_out(vty
, "level %s, facility %s, ident %s",
2346 zlog_priority
[zl
->maxlvl
[ZLOG_DEST_SYSLOG
]],
2347 facility_name(zl
->facility
), zl
->ident
);
2350 vty_out(vty
, "Stdout logging: ");
2351 if (zl
->maxlvl
[ZLOG_DEST_STDOUT
] == ZLOG_DISABLED
)
2352 vty_out(vty
, "disabled");
2354 vty_out(vty
, "level %s",
2355 zlog_priority
[zl
->maxlvl
[ZLOG_DEST_STDOUT
]]);
2358 vty_out(vty
, "Monitor logging: ");
2359 if (zl
->maxlvl
[ZLOG_DEST_MONITOR
] == ZLOG_DISABLED
)
2360 vty_out(vty
, "disabled");
2362 vty_out(vty
, "level %s",
2363 zlog_priority
[zl
->maxlvl
[ZLOG_DEST_MONITOR
]]);
2366 vty_out(vty
, "File logging: ");
2367 if ((zl
->maxlvl
[ZLOG_DEST_FILE
] == ZLOG_DISABLED
) || !zl
->fp
)
2368 vty_out(vty
, "disabled");
2370 vty_out(vty
, "level %s, filename %s",
2371 zlog_priority
[zl
->maxlvl
[ZLOG_DEST_FILE
]],
2375 vty_out(vty
, "Protocol name: %s\n", zl
->protoname
);
2376 vty_out(vty
, "Record priority: %s\n",
2377 (zl
->record_priority
? "enabled" : "disabled"));
2378 vty_out(vty
, "Timestamp precision: %d\n", zl
->timestamp_precision
);
2383 DEFUN (config_log_stdout
,
2384 config_log_stdout_cmd
,
2385 "log stdout [<emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>]",
2387 "Set stdout logging level\n"
2390 int idx_log_level
= 2;
2392 if (argc
== idx_log_level
) {
2393 zlog_set_level(ZLOG_DEST_STDOUT
, zlog_default
->default_lvl
);
2398 if ((level
= level_match(argv
[idx_log_level
]->arg
)) == ZLOG_DISABLED
)
2399 return CMD_ERR_NO_MATCH
;
2400 zlog_set_level(ZLOG_DEST_STDOUT
, level
);
2404 DEFUN (no_config_log_stdout
,
2405 no_config_log_stdout_cmd
,
2406 "no log stdout [<emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>]",
2409 "Cancel logging to stdout\n"
2412 zlog_set_level(ZLOG_DEST_STDOUT
, ZLOG_DISABLED
);
2416 DEFUN (config_log_monitor
,
2417 config_log_monitor_cmd
,
2418 "log monitor [<emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>]",
2420 "Set terminal line (monitor) logging level\n"
2423 int idx_log_level
= 2;
2425 if (argc
== idx_log_level
) {
2426 zlog_set_level(ZLOG_DEST_MONITOR
, zlog_default
->default_lvl
);
2431 if ((level
= level_match(argv
[idx_log_level
]->arg
)) == ZLOG_DISABLED
)
2432 return CMD_ERR_NO_MATCH
;
2433 zlog_set_level(ZLOG_DEST_MONITOR
, level
);
2437 DEFUN (no_config_log_monitor
,
2438 no_config_log_monitor_cmd
,
2439 "no log monitor [<emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>]",
2442 "Disable terminal line (monitor) logging\n"
2445 zlog_set_level(ZLOG_DEST_MONITOR
, ZLOG_DISABLED
);
2449 static int set_log_file(struct vty
*vty
, const char *fname
, int loglevel
)
2453 const char *fullpath
;
2455 /* Path detection. */
2456 if (!IS_DIRECTORY_SEP(*fname
)) {
2457 char cwd
[MAXPATHLEN
+ 1];
2458 cwd
[MAXPATHLEN
] = '\0';
2460 if (getcwd(cwd
, MAXPATHLEN
) == NULL
) {
2461 flog_err_sys(EC_LIB_SYSTEM_CALL
,
2462 "config_log_file: Unable to alloc mem!");
2463 return CMD_WARNING_CONFIG_FAILED
;
2466 p
= XMALLOC(MTYPE_TMP
, strlen(cwd
) + strlen(fname
) + 2);
2467 sprintf(p
, "%s/%s", cwd
, fname
);
2472 ret
= zlog_set_file(fullpath
, loglevel
);
2475 XFREE(MTYPE_TMP
, p
);
2479 vty_out(vty
, "can't open logfile %s\n", fname
);
2480 return CMD_WARNING_CONFIG_FAILED
;
2484 XFREE(MTYPE_HOST
, host
.logfile
);
2486 host
.logfile
= XSTRDUP(MTYPE_HOST
, fname
);
2488 #if defined(HAVE_CUMULUS)
2489 if (zlog_default
->maxlvl
[ZLOG_DEST_SYSLOG
] != ZLOG_DISABLED
)
2490 zlog_set_level(ZLOG_DEST_SYSLOG
, ZLOG_DISABLED
);
2495 void command_setup_early_logging(const char *dest
, const char *level
)
2500 int nlevel
= level_match(level
);
2502 if (nlevel
!= ZLOG_DISABLED
)
2503 zlog_default
->default_lvl
= nlevel
;
2509 if (strcmp(dest
, "stdout") == 0) {
2510 zlog_set_level(ZLOG_DEST_STDOUT
, zlog_default
->default_lvl
);
2514 if (strcmp(dest
, "syslog") == 0) {
2515 zlog_set_level(ZLOG_DEST_SYSLOG
, zlog_default
->default_lvl
);
2519 token
= strstr(dest
, ":");
2525 set_log_file(NULL
, token
, zlog_default
->default_lvl
);
2528 DEFUN (config_log_file
,
2529 config_log_file_cmd
,
2530 "log file FILENAME [<emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>]",
2533 "Logging filename\n"
2536 int idx_filename
= 2;
2537 int idx_log_levels
= 3;
2540 if ((level
= level_match(argv
[idx_log_levels
]->arg
))
2542 return CMD_ERR_NO_MATCH
;
2543 return set_log_file(vty
, argv
[idx_filename
]->arg
, level
);
2545 return set_log_file(vty
, argv
[idx_filename
]->arg
,
2546 zlog_default
->default_lvl
);
2549 static void disable_log_file(void)
2554 XFREE(MTYPE_HOST
, host
.logfile
);
2556 host
.logfile
= NULL
;
2559 DEFUN (no_config_log_file
,
2560 no_config_log_file_cmd
,
2561 "no log file [FILENAME [LEVEL]]",
2564 "Cancel logging to file\n"
2565 "Logging file name\n"
2572 DEFUN (config_log_syslog
,
2573 config_log_syslog_cmd
,
2574 "log syslog [<emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>]",
2576 "Set syslog logging level\n"
2579 int idx_log_levels
= 2;
2585 if ((level
= level_match(argv
[idx_log_levels
]->arg
))
2587 return CMD_ERR_NO_MATCH
;
2588 zlog_set_level(ZLOG_DEST_SYSLOG
, level
);
2591 zlog_set_level(ZLOG_DEST_SYSLOG
, zlog_default
->default_lvl
);
2596 DEFUN (no_config_log_syslog
,
2597 no_config_log_syslog_cmd
,
2598 "no log syslog [<kern|user|mail|daemon|auth|syslog|lpr|news|uucp|cron|local0|local1|local2|local3|local4|local5|local6|local7>] [<emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>]",
2601 "Cancel logging to syslog\n"
2605 zlog_set_level(ZLOG_DEST_SYSLOG
, ZLOG_DISABLED
);
2609 DEFUN (config_log_facility
,
2610 config_log_facility_cmd
,
2611 "log facility <kern|user|mail|daemon|auth|syslog|lpr|news|uucp|cron|local0|local1|local2|local3|local4|local5|local6|local7>",
2613 "Facility parameter for syslog messages\n"
2617 int facility
= facility_match(argv
[idx_target
]->arg
);
2619 zlog_default
->facility
= facility
;
2623 DEFUN (no_config_log_facility
,
2624 no_config_log_facility_cmd
,
2625 "no log facility [<kern|user|mail|daemon|auth|syslog|lpr|news|uucp|cron|local0|local1|local2|local3|local4|local5|local6|local7>]",
2628 "Reset syslog facility to default (daemon)\n"
2631 zlog_default
->facility
= LOG_DAEMON
;
2635 DEFUN (config_log_record_priority
,
2636 config_log_record_priority_cmd
,
2637 "log record-priority",
2639 "Log the priority of the message within the message\n")
2641 zlog_default
->record_priority
= 1;
2645 DEFUN (no_config_log_record_priority
,
2646 no_config_log_record_priority_cmd
,
2647 "no log record-priority",
2650 "Do not log the priority of the message within the message\n")
2652 zlog_default
->record_priority
= 0;
2656 DEFUN (config_log_timestamp_precision
,
2657 config_log_timestamp_precision_cmd
,
2658 "log timestamp precision (0-6)",
2660 "Timestamp configuration\n"
2661 "Set the timestamp precision\n"
2662 "Number of subsecond digits\n")
2665 zlog_default
->timestamp_precision
=
2666 strtoul(argv
[idx_number
]->arg
, NULL
, 10);
2670 DEFUN (no_config_log_timestamp_precision
,
2671 no_config_log_timestamp_precision_cmd
,
2672 "no log timestamp precision",
2675 "Timestamp configuration\n"
2676 "Reset the timestamp precision to the default value of 0\n")
2678 zlog_default
->timestamp_precision
= 0;
2682 DEFUN (debug_memstats
,
2684 "[no] debug memstats-at-exit",
2687 "Print memory type statistics at exit\n")
2689 debug_memstats_at_exit
= !!strcmp(argv
[0]->text
, "no");
2693 int cmd_banner_motd_file(const char *file
)
2695 int success
= CMD_SUCCESS
;
2700 rpath
= realpath(file
, p
);
2702 return CMD_ERR_NO_FILE
;
2703 in
= strstr(rpath
, SYSCONFDIR
);
2706 XFREE(MTYPE_HOST
, host
.motdfile
);
2707 host
.motdfile
= XSTRDUP(MTYPE_HOST
, file
);
2709 success
= CMD_WARNING_CONFIG_FAILED
;
2714 DEFUN (banner_motd_file
,
2715 banner_motd_file_cmd
,
2716 "banner motd file FILE",
2719 "Banner from a file\n"
2723 const char *filename
= argv
[idx_file
]->arg
;
2724 int cmd
= cmd_banner_motd_file(filename
);
2726 if (cmd
== CMD_ERR_NO_FILE
)
2727 vty_out(vty
, "%s does not exist", filename
);
2728 else if (cmd
== CMD_WARNING_CONFIG_FAILED
)
2729 vty_out(vty
, "%s must be in %s", filename
, SYSCONFDIR
);
2734 DEFUN (banner_motd_default
,
2735 banner_motd_default_cmd
,
2736 "banner motd default",
2737 "Set banner string\n"
2738 "Strings for motd\n"
2741 host
.motd
= default_motd
;
2745 DEFUN (no_banner_motd
,
2749 "Set banner string\n"
2750 "Strings for motd\n")
2754 XFREE(MTYPE_HOST
, host
.motdfile
);
2755 host
.motdfile
= NULL
;
2762 "Find CLI command containing text\n"
2763 "Text to search for\n")
2765 char *text
= argv_concat(argv
, argc
, 1);
2766 const struct cmd_node
*node
;
2767 const struct cmd_element
*cli
;
2770 for (unsigned int i
= 0; i
< vector_active(cmdvec
); i
++) {
2771 node
= vector_slot(cmdvec
, i
);
2774 clis
= node
->cmd_vector
;
2775 for (unsigned int j
= 0; j
< vector_active(clis
); j
++) {
2776 cli
= vector_slot(clis
, j
);
2777 if (strcasestr(cli
->string
, text
))
2778 vty_out(vty
, " (%s) %s\n",
2779 node_names
[node
->node
], cli
->string
);
2783 XFREE(MTYPE_TMP
, text
);
2788 /* Set config filename. Called from vty.c */
2789 void host_config_set(const char *filename
)
2792 XFREE(MTYPE_HOST
, host
.config
);
2793 host
.config
= XSTRDUP(MTYPE_HOST
, filename
);
2796 const char *host_config_get(void)
2801 void install_default(enum node_type node
)
2803 install_element(node
, &config_exit_cmd
);
2804 install_element(node
, &config_quit_cmd
);
2805 install_element(node
, &config_end_cmd
);
2806 install_element(node
, &config_help_cmd
);
2807 install_element(node
, &config_list_cmd
);
2808 install_element(node
, &show_cli_graph_cmd
);
2809 install_element(node
, &find_cmd
);
2811 install_element(node
, &config_write_cmd
);
2812 install_element(node
, &show_running_config_cmd
);
2814 install_element(node
, &autocomplete_cmd
);
2816 nb_cli_install_default(node
);
2819 /* Initialize command interface. Install basic nodes and commands.
2821 * terminal = 0 -- vtysh / no logging, no config control
2822 * terminal = 1 -- normal daemon
2823 * terminal = -1 -- watchfrr / no logging, but minimal config control */
2824 void cmd_init(int terminal
)
2826 struct utsname names
;
2828 if (array_size(node_names
) != NODE_TYPE_MAX
)
2829 assert(!"Update the CLI node description array!");
2834 /* register command preprocessors */
2835 hook_register(cmd_execute
, handle_pipe_action
);
2836 hook_register(cmd_execute_done
, handle_pipe_action_done
);
2838 varhandlers
= list_new();
2840 /* Allocate initial top vector of commands. */
2841 cmdvec
= vector_init(VECTOR_MIN_SIZE
);
2843 /* Default host value settings. */
2844 host
.name
= XSTRDUP(MTYPE_HOST
, names
.nodename
);
2845 #ifdef HAVE_STRUCT_UTSNAME_DOMAINNAME
2846 if ((strcmp(names
.domainname
, "(none)") == 0))
2847 host
.domainname
= NULL
;
2849 host
.domainname
= XSTRDUP(MTYPE_HOST
, names
.domainname
);
2851 host
.domainname
= NULL
;
2853 host
.password
= NULL
;
2855 host
.logfile
= NULL
;
2857 host
.noconfig
= (terminal
< 0);
2859 host
.motd
= default_motd
;
2860 host
.motdfile
= NULL
;
2862 /* Install top nodes. */
2863 install_node(&view_node
, NULL
);
2864 install_node(&enable_node
, NULL
);
2865 install_node(&auth_node
, NULL
);
2866 install_node(&auth_enable_node
, NULL
);
2867 install_node(&config_node
, config_write_host
);
2869 /* Each node's basic commands. */
2870 install_element(VIEW_NODE
, &show_version_cmd
);
2871 install_element(ENABLE_NODE
, &show_startup_config_cmd
);
2872 install_element(ENABLE_NODE
, &debug_memstats_cmd
);
2875 install_element(VIEW_NODE
, &config_list_cmd
);
2876 install_element(VIEW_NODE
, &config_exit_cmd
);
2877 install_element(VIEW_NODE
, &config_quit_cmd
);
2878 install_element(VIEW_NODE
, &config_help_cmd
);
2879 install_element(VIEW_NODE
, &config_enable_cmd
);
2880 install_element(VIEW_NODE
, &config_terminal_length_cmd
);
2881 install_element(VIEW_NODE
, &config_terminal_no_length_cmd
);
2882 install_element(VIEW_NODE
, &show_logging_cmd
);
2883 install_element(VIEW_NODE
, &show_commandtree_cmd
);
2884 install_element(VIEW_NODE
, &echo_cmd
);
2885 install_element(VIEW_NODE
, &autocomplete_cmd
);
2886 install_element(VIEW_NODE
, &find_cmd
);
2888 install_element(ENABLE_NODE
, &config_end_cmd
);
2889 install_element(ENABLE_NODE
, &config_disable_cmd
);
2890 install_element(ENABLE_NODE
, &config_terminal_cmd
);
2891 install_element(ENABLE_NODE
, ©_runningconf_startupconf_cmd
);
2892 install_element(ENABLE_NODE
, &config_write_cmd
);
2893 install_element(ENABLE_NODE
, &show_running_config_cmd
);
2894 install_element(ENABLE_NODE
, &config_logmsg_cmd
);
2896 install_default(CONFIG_NODE
);
2899 workqueue_cmd_init();
2903 install_element(CONFIG_NODE
, &hostname_cmd
);
2904 install_element(CONFIG_NODE
, &no_hostname_cmd
);
2905 install_element(CONFIG_NODE
, &domainname_cmd
);
2906 install_element(CONFIG_NODE
, &no_domainname_cmd
);
2907 install_element(CONFIG_NODE
, &frr_version_defaults_cmd
);
2908 install_element(CONFIG_NODE
, &debug_memstats_cmd
);
2911 install_element(CONFIG_NODE
, &password_cmd
);
2912 install_element(CONFIG_NODE
, &no_password_cmd
);
2913 install_element(CONFIG_NODE
, &enable_password_cmd
);
2914 install_element(CONFIG_NODE
, &no_enable_password_cmd
);
2916 install_element(CONFIG_NODE
, &config_log_stdout_cmd
);
2917 install_element(CONFIG_NODE
, &no_config_log_stdout_cmd
);
2918 install_element(CONFIG_NODE
, &config_log_monitor_cmd
);
2919 install_element(CONFIG_NODE
, &no_config_log_monitor_cmd
);
2920 install_element(CONFIG_NODE
, &config_log_file_cmd
);
2921 install_element(CONFIG_NODE
, &no_config_log_file_cmd
);
2922 install_element(CONFIG_NODE
, &config_log_syslog_cmd
);
2923 install_element(CONFIG_NODE
, &no_config_log_syslog_cmd
);
2924 install_element(CONFIG_NODE
, &config_log_facility_cmd
);
2925 install_element(CONFIG_NODE
, &no_config_log_facility_cmd
);
2926 install_element(CONFIG_NODE
, &config_log_record_priority_cmd
);
2927 install_element(CONFIG_NODE
,
2928 &no_config_log_record_priority_cmd
);
2929 install_element(CONFIG_NODE
,
2930 &config_log_timestamp_precision_cmd
);
2931 install_element(CONFIG_NODE
,
2932 &no_config_log_timestamp_precision_cmd
);
2933 install_element(CONFIG_NODE
, &service_password_encrypt_cmd
);
2934 install_element(CONFIG_NODE
, &no_service_password_encrypt_cmd
);
2935 install_element(CONFIG_NODE
, &banner_motd_default_cmd
);
2936 install_element(CONFIG_NODE
, &banner_motd_file_cmd
);
2937 install_element(CONFIG_NODE
, &no_banner_motd_cmd
);
2938 install_element(CONFIG_NODE
, &service_terminal_length_cmd
);
2939 install_element(CONFIG_NODE
, &no_service_terminal_length_cmd
);
2941 vrf_install_commands();
2945 grammar_sandbox_init();
2949 void cmd_terminate()
2951 struct cmd_node
*cmd_node
;
2953 hook_unregister(cmd_execute
, handle_pipe_action
);
2954 hook_unregister(cmd_execute_done
, handle_pipe_action_done
);
2957 for (unsigned int i
= 0; i
< vector_active(cmdvec
); i
++)
2958 if ((cmd_node
= vector_slot(cmdvec
, i
)) != NULL
) {
2959 // deleting the graph delets the cmd_element as
2961 graph_delete_graph(cmd_node
->cmdgraph
);
2962 vector_free(cmd_node
->cmd_vector
);
2963 hash_clean(cmd_node
->cmd_hash
, NULL
);
2964 hash_free(cmd_node
->cmd_hash
);
2965 cmd_node
->cmd_hash
= NULL
;
2968 vector_free(cmdvec
);
2973 XFREE(MTYPE_HOST
, host
.name
);
2974 if (host
.domainname
)
2975 XFREE(MTYPE_HOST
, host
.domainname
);
2977 XFREE(MTYPE_HOST
, host
.password
);
2978 if (host
.password_encrypt
)
2979 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2981 XFREE(MTYPE_HOST
, host
.enable
);
2982 if (host
.enable_encrypt
)
2983 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2985 XFREE(MTYPE_HOST
, host
.logfile
);
2987 XFREE(MTYPE_HOST
, host
.motdfile
);
2989 XFREE(MTYPE_HOST
, host
.config
);
2991 list_delete(&varhandlers
);