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 /* Clear enqueued configuration changes. */
1056 vty
->num_cfg_changes
= 0;
1057 memset(&vty
->cfg_changes
, 0, sizeof(vty
->cfg_changes
));
1059 ret
= matched_element
->func(matched_element
, vty
, argc
, argv
);
1062 // delete list and cmd_token's in it
1063 list_delete(&argv_list
);
1064 XFREE(MTYPE_TMP
, argv
);
1070 * Execute a given command, handling things like "do ..." and checking
1071 * whether the given command might apply at a parent node if doesn't
1072 * apply for the current node.
1074 * @param vline Command line input, vector of char* where each element is
1076 * @param vty The vty context in which the command should be executed.
1077 * @param cmd Pointer where the struct cmd_element of the matched command
1078 * will be stored, if any. May be set to NULL if this info is
1080 * @param vtysh If set != 0, don't lookup the command at parent nodes.
1081 * @return The status of the command that has been executed or an error code
1082 * as to why no command could be executed.
1084 int cmd_execute_command(vector vline
, struct vty
*vty
,
1085 const struct cmd_element
**cmd
, int vtysh
)
1087 int ret
, saved_ret
= 0;
1088 enum node_type onode
, try_node
;
1089 int orig_xpath_index
;
1091 onode
= try_node
= vty
->node
;
1092 orig_xpath_index
= vty
->xpath_index
;
1094 if (cmd_try_do_shortcut(vty
->node
, vector_slot(vline
, 0))) {
1095 vector shifted_vline
;
1098 vty
->node
= ENABLE_NODE
;
1099 vty
->xpath_index
= 0;
1100 /* We can try it on enable node, cos' the vty is authenticated
1103 shifted_vline
= vector_init(vector_count(vline
));
1105 for (index
= 1; index
< vector_active(vline
); index
++)
1106 vector_set_index(shifted_vline
, index
- 1,
1107 vector_lookup(vline
, index
));
1109 ret
= cmd_execute_command_real(shifted_vline
, FILTER_RELAXED
,
1112 vector_free(shifted_vline
);
1114 vty
->xpath_index
= orig_xpath_index
;
1119 cmd_execute_command_real(vline
, FILTER_RELAXED
, vty
, cmd
);
1124 if (ret
!= CMD_SUCCESS
&& ret
!= CMD_WARNING
1125 && ret
!= CMD_NOT_MY_INSTANCE
&& ret
!= CMD_WARNING_CONFIG_FAILED
) {
1126 /* This assumes all nodes above CONFIG_NODE are childs of
1128 while (vty
->node
> CONFIG_NODE
) {
1129 try_node
= node_parent(try_node
);
1130 vty
->node
= try_node
;
1131 if (vty
->xpath_index
> 0)
1133 ret
= cmd_execute_command_real(vline
, FILTER_RELAXED
,
1135 if (ret
== CMD_SUCCESS
|| ret
== CMD_WARNING
1136 || ret
== CMD_NOT_MY_INSTANCE
1137 || ret
== CMD_WARNING_CONFIG_FAILED
)
1140 /* no command succeeded, reset the vty to the original node */
1142 vty
->xpath_index
= orig_xpath_index
;
1145 /* return command status for original node */
1150 * Execute a given command, matching it strictly against the current node.
1151 * This mode is used when reading config files.
1153 * @param vline Command line input, vector of char* where each element is
1155 * @param vty The vty context in which the command should be executed.
1156 * @param cmd Pointer where the struct cmd_element* of the matched command
1157 * will be stored, if any. May be set to NULL if this info is
1159 * @return The status of the command that has been executed or an error code
1160 * as to why no command could be executed.
1162 int cmd_execute_command_strict(vector vline
, struct vty
*vty
,
1163 const struct cmd_element
**cmd
)
1165 return cmd_execute_command_real(vline
, FILTER_STRICT
, vty
, cmd
);
1169 * Hook for preprocessing command string before executing.
1171 * All subscribers are called with the raw command string that is to be
1172 * executed. If any changes are to be made, a new string should be allocated
1173 * with MTYPE_TMP and *cmd_out updated to point to this new string. The caller
1174 * is then responsible for freeing this string.
1176 * All processing functions must be mutually exclusive in their action, i.e. if
1177 * one subscriber decides to modify the command, all others must not modify it
1178 * when called. Feeding the output of one processing command into a subsequent
1179 * one is not supported.
1181 * This hook is intentionally internal to the command processing system.
1184 * The raw command string.
1187 * The result of any processing.
1189 DECLARE_HOOK(cmd_execute
,
1190 (struct vty
*vty
, const char *cmd_in
, char **cmd_out
),
1191 (vty
, cmd_in
, cmd_out
));
1192 DEFINE_HOOK(cmd_execute
, (struct vty
*vty
, const char *cmd_in
, char **cmd_out
),
1193 (vty
, cmd_in
, cmd_out
));
1195 /* Hook executed after a CLI command. */
1196 DECLARE_KOOH(cmd_execute_done
, (struct vty
*vty
, const char *cmd_exec
),
1198 DEFINE_KOOH(cmd_execute_done
, (struct vty
*vty
, const char *cmd_exec
),
1202 * cmd_execute hook subscriber to handle `|` actions.
1204 static int handle_pipe_action(struct vty
*vty
, const char *cmd_in
,
1208 char *orig
, *working
, *token
, *u
;
1209 char *pipe
= strstr(cmd_in
, "| ");
1214 /* duplicate string for processing purposes, not including pipe */
1215 orig
= working
= XSTRDUP(MTYPE_TMP
, pipe
+ 2);
1217 /* retrieve action */
1218 token
= strsep(&working
, " ");
1221 /* match result to known actions */
1222 if (strmatch(token
, "include")) {
1223 /* the remaining text should be a regexp */
1224 char *regexp
= working
;
1227 vty_out(vty
, "%% Need a regexp to filter with\n");
1231 bool succ
= vty_set_include(vty
, regexp
);
1234 vty_out(vty
, "%% Bad regexp '%s'\n", regexp
);
1237 *cmd_out
= XSTRDUP(MTYPE_TMP
, cmd_in
);
1241 vty_out(vty
, "%% Unknown action '%s'\n", token
);
1246 XFREE(MTYPE_TMP
, orig
);
1250 static int handle_pipe_action_done(struct vty
*vty
, const char *cmd_exec
)
1253 vty_set_include(vty
, NULL
);
1258 int cmd_execute(struct vty
*vty
, const char *cmd
,
1259 const struct cmd_element
**matched
, int vtysh
)
1262 char *cmd_out
= NULL
;
1263 const char *cmd_exec
;
1266 hook_call(cmd_execute
, vty
, cmd
, &cmd_out
);
1267 cmd_exec
= cmd_out
? (const char *)cmd_out
: cmd
;
1269 vline
= cmd_make_strvec(cmd_exec
);
1272 ret
= cmd_execute_command(vline
, vty
, matched
, vtysh
);
1273 cmd_free_strvec(vline
);
1278 hook_call(cmd_execute_done
, vty
, cmd_exec
);
1281 XFREE(MTYPE_TMP
, cmd_out
);
1288 * Parse one line of config, walking up the parse tree attempting to find a
1291 * @param vty The vty context in which the command should be executed.
1292 * @param cmd Pointer where the struct cmd_element* of the match command
1293 * will be stored, if any. May be set to NULL if this info is
1295 * @param use_daemon Boolean to control whether or not we match on
1296 * CMD_SUCCESS_DAEMON
1298 * @return The status of the command that has been executed or an error code
1299 * as to why no command could be executed.
1301 int command_config_read_one_line(struct vty
*vty
,
1302 const struct cmd_element
**cmd
,
1303 uint32_t line_num
, int use_daemon
)
1308 vline
= cmd_make_strvec(vty
->buf
);
1310 /* In case of comment line */
1314 /* Execute configuration command : this is strict match */
1315 ret
= cmd_execute_command_strict(vline
, vty
, cmd
);
1317 // Climb the tree and try the command again at each node
1318 if (!(use_daemon
&& ret
== CMD_SUCCESS_DAEMON
)
1319 && !(!use_daemon
&& ret
== CMD_ERR_NOTHING_TODO
)
1320 && ret
!= CMD_SUCCESS
&& ret
!= CMD_WARNING
1321 && ret
!= CMD_NOT_MY_INSTANCE
&& ret
!= CMD_WARNING_CONFIG_FAILED
1322 && vty
->node
!= CONFIG_NODE
) {
1323 int saved_node
= vty
->node
;
1324 int saved_xpath_index
= vty
->xpath_index
;
1326 while (!(use_daemon
&& ret
== CMD_SUCCESS_DAEMON
)
1327 && !(!use_daemon
&& ret
== CMD_ERR_NOTHING_TODO
)
1328 && ret
!= CMD_SUCCESS
&& ret
!= CMD_WARNING
1329 && vty
->node
> CONFIG_NODE
) {
1330 vty
->node
= node_parent(vty
->node
);
1331 if (vty
->xpath_index
> 0)
1333 ret
= cmd_execute_command_strict(vline
, vty
, cmd
);
1336 // If climbing the tree did not work then ignore the command and
1337 // stay at the same node
1338 if (!(use_daemon
&& ret
== CMD_SUCCESS_DAEMON
)
1339 && !(!use_daemon
&& ret
== CMD_ERR_NOTHING_TODO
)
1340 && ret
!= CMD_SUCCESS
&& ret
!= CMD_WARNING
) {
1341 vty
->node
= saved_node
;
1342 vty
->xpath_index
= saved_xpath_index
;
1346 if (ret
!= CMD_SUCCESS
&&
1347 ret
!= CMD_WARNING
&&
1348 ret
!= CMD_SUCCESS_DAEMON
) {
1349 struct vty_error
*ve
= XCALLOC(MTYPE_TMP
, sizeof(*ve
));
1351 memcpy(ve
->error_buf
, vty
->buf
, VTY_BUFSIZ
);
1352 ve
->line_num
= line_num
;
1354 vty
->error
= list_new();
1356 listnode_add(vty
->error
, ve
);
1359 cmd_free_strvec(vline
);
1364 /* Configuration make from file. */
1365 int config_from_file(struct vty
*vty
, FILE *fp
, unsigned int *line_num
)
1367 int ret
, error_ret
= 0;
1370 while (fgets(vty
->buf
, VTY_BUFSIZ
, fp
)) {
1373 ret
= command_config_read_one_line(vty
, NULL
, *line_num
, 0);
1375 if (ret
!= CMD_SUCCESS
&& ret
!= CMD_WARNING
1376 && ret
!= CMD_ERR_NOTHING_TODO
)
1387 /* Configuration from terminal */
1388 DEFUN (config_terminal
,
1389 config_terminal_cmd
,
1390 "configure terminal",
1391 "Configuration from vty interface\n"
1392 "Configuration terminal\n")
1394 if (vty_config_lock(vty
))
1395 vty
->node
= CONFIG_NODE
;
1397 vty_out(vty
, "VTY configuration is locked by other VTY\n");
1398 return CMD_WARNING_CONFIG_FAILED
;
1401 vty
->private_config
= false;
1402 vty
->candidate_config
= vty_shared_candidate_config
;
1403 if (frr_get_cli_mode() == FRR_CLI_TRANSACTIONAL
)
1404 vty
->candidate_config_base
= nb_config_dup(running_config
);
1409 /* Enable command */
1413 "Turn on privileged mode command\n")
1415 /* If enable password is NULL, change to ENABLE_NODE */
1416 if ((host
.enable
== NULL
&& host
.enable_encrypt
== NULL
)
1417 || vty
->type
== VTY_SHELL_SERV
)
1418 vty
->node
= ENABLE_NODE
;
1420 vty
->node
= AUTH_ENABLE_NODE
;
1425 /* Disable command */
1429 "Turn off privileged mode command\n")
1431 if (vty
->node
== ENABLE_NODE
)
1432 vty
->node
= VIEW_NODE
;
1436 /* Down vty node level. */
1440 "Exit current mode and down to previous mode\n")
1446 void cmd_exit(struct vty
*vty
)
1448 switch (vty
->node
) {
1454 vty
->status
= VTY_CLOSE
;
1457 vty
->node
= ENABLE_NODE
;
1458 vty_config_unlock(vty
);
1460 case INTERFACE_NODE
:
1462 case LOGICALROUTER_NODE
:
1474 case LDP_L2VPN_NODE
:
1476 case OPENFABRIC_NODE
:
1482 vty
->node
= CONFIG_NODE
;
1485 case BGP_IPV4M_NODE
:
1486 case BGP_IPV4L_NODE
:
1487 case BGP_VPNV4_NODE
:
1488 case BGP_VPNV6_NODE
:
1489 case BGP_FLOWSPECV4_NODE
:
1490 case BGP_FLOWSPECV6_NODE
:
1491 case BGP_VRF_POLICY_NODE
:
1492 case BGP_VNC_DEFAULTS_NODE
:
1493 case BGP_VNC_NVE_GROUP_NODE
:
1494 case BGP_VNC_L2_GROUP_NODE
:
1496 case BGP_IPV6M_NODE
:
1498 case BGP_IPV6L_NODE
:
1499 vty
->node
= BGP_NODE
;
1501 case BGP_EVPN_VNI_NODE
:
1502 vty
->node
= BGP_EVPN_NODE
;
1506 vty
->node
= LDP_NODE
;
1508 case LDP_IPV4_IFACE_NODE
:
1509 vty
->node
= LDP_IPV4_NODE
;
1511 case LDP_IPV6_IFACE_NODE
:
1512 vty
->node
= LDP_IPV6_NODE
;
1514 case LDP_PSEUDOWIRE_NODE
:
1515 vty
->node
= LDP_L2VPN_NODE
;
1517 case KEYCHAIN_KEY_NODE
:
1518 vty
->node
= KEYCHAIN_NODE
;
1520 case LINK_PARAMS_NODE
:
1521 vty
->node
= INTERFACE_NODE
;
1524 vty
->node
= BFD_NODE
;
1530 if (vty
->xpath_index
> 0)
1538 "Exit current mode and down to previous mode\n")
1540 return config_exit(self
, vty
, argc
, argv
);
1544 /* End of configuration. */
1548 "End current mode and change to enable mode.\n")
1550 switch (vty
->node
) {
1553 /* Nothing to do. */
1556 case INTERFACE_NODE
:
1558 case LOGICALROUTER_NODE
:
1567 case BGP_VRF_POLICY_NODE
:
1568 case BGP_VNC_DEFAULTS_NODE
:
1569 case BGP_VNC_NVE_GROUP_NODE
:
1570 case BGP_VNC_L2_GROUP_NODE
:
1571 case BGP_VPNV4_NODE
:
1572 case BGP_VPNV6_NODE
:
1573 case BGP_FLOWSPECV4_NODE
:
1574 case BGP_FLOWSPECV6_NODE
:
1576 case BGP_IPV4M_NODE
:
1577 case BGP_IPV4L_NODE
:
1579 case BGP_IPV6M_NODE
:
1581 case BGP_EVPN_VNI_NODE
:
1582 case BGP_IPV6L_NODE
:
1590 case LDP_IPV4_IFACE_NODE
:
1591 case LDP_IPV6_IFACE_NODE
:
1592 case LDP_L2VPN_NODE
:
1593 case LDP_PSEUDOWIRE_NODE
:
1595 case OPENFABRIC_NODE
:
1597 case KEYCHAIN_KEY_NODE
:
1599 case LINK_PARAMS_NODE
:
1602 vty_config_unlock(vty
);
1603 vty
->node
= ENABLE_NODE
;
1609 vty
->xpath_index
= 0;
1615 DEFUN (show_version
,
1619 "Displays zebra version\n")
1621 vty_out(vty
, "%s %s (%s).\n", FRR_FULL_NAME
, FRR_VERSION
,
1622 cmd_hostname_get() ? cmd_hostname_get() : "");
1623 vty_out(vty
, "%s%s\n", FRR_COPYRIGHT
, GIT_INFO
);
1624 vty_out(vty
, "configured with:\n %s\n", FRR_CONFIG_ARGS
);
1629 /* "Set" version ... ignore version tags */
1630 DEFUN (frr_version_defaults
,
1631 frr_version_defaults_cmd
,
1632 "frr <version|defaults> LINE...",
1633 "FRRouting global parameters\n"
1634 "version configuration was written by\n"
1635 "set of configuration defaults used\n"
1641 /* Help display function for all node. */
1645 "Description of the interactive help system\n")
1648 "Quagga VTY provides advanced help feature. When you need help,\n\
1649 anytime at the command line please press '?'.\n\
1651 If nothing matches, the help list will be empty and you must backup\n\
1652 until entering a '?' shows the available options.\n\
1653 Two styles of help are provided:\n\
1654 1. Full help is available when you are ready to enter a\n\
1655 command argument (e.g. 'show ?') and describes each possible\n\
1657 2. Partial help is provided when an abbreviated argument is entered\n\
1658 and you want to know what arguments match the input\n\
1659 (e.g. 'show me?'.)\n\n");
1663 static void permute(struct graph_node
*start
, struct vty
*vty
)
1665 static struct list
*position
= NULL
;
1667 position
= list_new();
1669 struct cmd_token
*stok
= start
->data
;
1670 struct graph_node
*gnn
;
1671 struct listnode
*ln
;
1674 listnode_add(position
, start
);
1675 for (unsigned int i
= 0; i
< vector_active(start
->to
); i
++) {
1676 struct graph_node
*gn
= vector_slot(start
->to
, i
);
1677 struct cmd_token
*tok
= gn
->data
;
1678 if (tok
->attr
== CMD_ATTR_HIDDEN
1679 || tok
->attr
== CMD_ATTR_DEPRECATED
)
1681 else if (tok
->type
== END_TKN
|| gn
== start
) {
1683 for (ALL_LIST_ELEMENTS_RO(position
, ln
, gnn
)) {
1684 struct cmd_token
*tt
= gnn
->data
;
1685 if (tt
->type
< SPECIAL_TKN
)
1686 vty_out(vty
, " %s", tt
->text
);
1689 vty_out(vty
, "...");
1693 if (stok
->type
== FORK_TKN
&& tok
->type
!= FORK_TKN
)
1694 for (ALL_LIST_ELEMENTS_RO(position
, ln
, gnn
))
1703 list_delete_node(position
, listtail(position
));
1706 int cmd_list_cmds(struct vty
*vty
, int do_permute
)
1708 struct cmd_node
*node
= vector_slot(cmdvec
, vty
->node
);
1711 permute(vector_slot(node
->cmdgraph
->nodes
, 0), vty
);
1713 /* loop over all commands at this node */
1714 struct cmd_element
*element
= NULL
;
1715 for (unsigned int i
= 0; i
< vector_active(node
->cmd_vector
);
1717 if ((element
= vector_slot(node
->cmd_vector
, i
))
1718 && element
->attr
!= CMD_ATTR_DEPRECATED
1719 && element
->attr
!= CMD_ATTR_HIDDEN
)
1720 vty_out(vty
, " %s\n", element
->string
);
1725 /* Help display function for all node. */
1728 "list [permutations]",
1729 "Print command list\n"
1730 "Print all possible command permutations\n")
1732 return cmd_list_cmds(vty
, argc
== 2);
1735 DEFUN (show_commandtree
,
1736 show_commandtree_cmd
,
1737 "show commandtree [permutations]",
1739 "Show command tree\n"
1740 "Permutations that we are interested in\n")
1742 return cmd_list_cmds(vty
, argc
== 3);
1745 DEFUN_HIDDEN(show_cli_graph
,
1750 "Dump current command space as DOT graph\n")
1752 struct cmd_node
*cn
= vector_slot(cmdvec
, vty
->node
);
1753 char *dot
= cmd_graph_dump_dot(cn
->cmdgraph
);
1755 vty_out(vty
, "%s\n", dot
);
1756 XFREE(MTYPE_TMP
, dot
);
1760 static int vty_write_config(struct vty
*vty
)
1763 struct cmd_node
*node
;
1768 if (vty
->type
== VTY_TERM
) {
1769 vty_out(vty
, "\nCurrent configuration:\n");
1770 vty_out(vty
, "!\n");
1773 vty_out(vty
, "frr version %s\n", FRR_VER_SHORT
);
1774 vty_out(vty
, "frr defaults %s\n", DFLT_NAME
);
1775 vty_out(vty
, "!\n");
1777 for (i
= 0; i
< vector_active(cmdvec
); i
++)
1778 if ((node
= vector_slot(cmdvec
, i
)) && node
->func
1779 && (node
->vtysh
|| vty
->type
!= VTY_SHELL
)) {
1780 if ((*node
->func
)(vty
))
1781 vty_out(vty
, "!\n");
1784 if (vty
->type
== VTY_TERM
) {
1785 vty_out(vty
, "end\n");
1791 static int file_write_config(struct vty
*vty
)
1794 char *config_file
, *slash
;
1795 char *config_file_tmp
= NULL
;
1796 char *config_file_sav
= NULL
;
1797 int ret
= CMD_WARNING
;
1798 struct vty
*file_vty
;
1799 struct stat conf_stat
;
1804 /* Check and see if we are operating under vtysh configuration */
1805 if (host
.config
== NULL
) {
1807 "Can't save to configuration file, using vtysh.\n");
1812 config_file
= host
.config
;
1815 #define O_DIRECTORY 0
1817 slash
= strrchr(config_file
, '/');
1819 char *config_dir
= XSTRDUP(MTYPE_TMP
, config_file
);
1820 config_dir
[slash
- config_file
] = '\0';
1821 dirfd
= open(config_dir
, O_DIRECTORY
| O_RDONLY
);
1822 XFREE(MTYPE_TMP
, config_dir
);
1824 dirfd
= open(".", O_DIRECTORY
| O_RDONLY
);
1825 /* if dirfd is invalid, directory sync fails, but we're still OK */
1827 config_file_sav
= XMALLOC(
1828 MTYPE_TMP
, strlen(config_file
) + strlen(CONF_BACKUP_EXT
) + 1);
1829 strcpy(config_file_sav
, config_file
);
1830 strcat(config_file_sav
, CONF_BACKUP_EXT
);
1833 config_file_tmp
= XMALLOC(MTYPE_TMP
, strlen(config_file
) + 8);
1834 sprintf(config_file_tmp
, "%s.XXXXXX", config_file
);
1836 /* Open file to configuration write. */
1837 fd
= mkstemp(config_file_tmp
);
1839 vty_out(vty
, "Can't open configuration file %s.\n",
1843 if (fchmod(fd
, CONFIGFILE_MASK
) != 0) {
1844 vty_out(vty
, "Can't chmod configuration file %s: %s (%d).\n",
1845 config_file_tmp
, safe_strerror(errno
), errno
);
1849 /* Make vty for configuration file. */
1850 file_vty
= vty_new();
1852 file_vty
->type
= VTY_FILE
;
1854 /* Config file header print. */
1855 vty_out(file_vty
, "!\n! Zebra configuration saved from vty\n! ");
1856 vty_time_print(file_vty
, 1);
1857 vty_out(file_vty
, "!\n");
1858 vty_write_config(file_vty
);
1859 vty_close(file_vty
);
1861 if (stat(config_file
, &conf_stat
) >= 0) {
1862 if (unlink(config_file_sav
) != 0)
1863 if (errno
!= ENOENT
) {
1865 "Can't unlink backup configuration file %s.\n",
1869 if (link(config_file
, config_file_sav
) != 0) {
1871 "Can't backup old configuration file %s.\n",
1878 if (rename(config_file_tmp
, config_file
) != 0) {
1879 vty_out(vty
, "Can't save configuration file %s.\n",
1886 vty_out(vty
, "Configuration saved to %s\n", config_file
);
1890 if (ret
!= CMD_SUCCESS
)
1891 unlink(config_file_tmp
);
1894 XFREE(MTYPE_TMP
, config_file_tmp
);
1895 XFREE(MTYPE_TMP
, config_file_sav
);
1899 /* Write current configuration into file. */
1901 DEFUN (config_write
,
1903 "write [<file|memory|terminal>]",
1904 "Write running configuration to memory, network, or terminal\n"
1905 "Write to configuration file\n"
1906 "Write configuration currently in memory\n"
1907 "Write configuration to terminal\n")
1909 const int idx_type
= 1;
1911 // if command was 'write terminal' or 'write memory'
1912 if (argc
== 2 && (!strcmp(argv
[idx_type
]->text
, "terminal"))) {
1913 return vty_write_config(vty
);
1916 return file_write_config(vty
);
1919 /* ALIAS_FIXME for 'write <terminal|memory>' */
1920 DEFUN (show_running_config
,
1921 show_running_config_cmd
,
1922 "show running-config",
1924 "running configuration (same as write terminal)\n")
1926 return vty_write_config(vty
);
1929 /* ALIAS_FIXME for 'write file' */
1930 DEFUN (copy_runningconf_startupconf
,
1931 copy_runningconf_startupconf_cmd
,
1932 "copy running-config startup-config",
1933 "Copy configuration\n"
1934 "Copy running config to... \n"
1935 "Copy running config to startup config (same as write file/memory)\n")
1937 return file_write_config(vty
);
1941 /* Write startup configuration into the terminal. */
1942 DEFUN (show_startup_config
,
1943 show_startup_config_cmd
,
1944 "show startup-config",
1946 "Contents of startup configuration\n")
1953 if (host
.config
== NULL
)
1956 confp
= fopen(host
.config
, "r");
1957 if (confp
== NULL
) {
1958 vty_out(vty
, "Can't open configuration file [%s] due to '%s'\n",
1959 host
.config
, safe_strerror(errno
));
1963 while (fgets(buf
, BUFSIZ
, confp
)) {
1966 while (*cp
!= '\r' && *cp
!= '\n' && *cp
!= '\0')
1970 vty_out(vty
, "%s\n", buf
);
1978 int cmd_domainname_set(const char *domainname
)
1980 XFREE(MTYPE_HOST
, host
.domainname
);
1981 host
.domainname
= domainname
? XSTRDUP(MTYPE_HOST
, domainname
) : NULL
;
1985 /* Hostname configuration */
1986 DEFUN(config_domainname
,
1989 "Set system's domain name\n"
1990 "This system's domain name\n")
1992 struct cmd_token
*word
= argv
[1];
1994 if (!isalpha((int)word
->arg
[0])) {
1995 vty_out(vty
, "Please specify string starting with alphabet\n");
1996 return CMD_WARNING_CONFIG_FAILED
;
1999 return cmd_domainname_set(word
->arg
);
2002 DEFUN(config_no_domainname
,
2004 "no domainname [DOMAINNAME]",
2006 "Reset system's domain name\n"
2007 "domain name of this router\n")
2009 return cmd_domainname_set(NULL
);
2012 int cmd_hostname_set(const char *hostname
)
2014 XFREE(MTYPE_HOST
, host
.name
);
2015 host
.name
= hostname
? XSTRDUP(MTYPE_HOST
, hostname
) : NULL
;
2019 /* Hostname configuration */
2020 DEFUN (config_hostname
,
2023 "Set system's network name\n"
2024 "This system's network name\n")
2026 struct cmd_token
*word
= argv
[1];
2028 if (!isalnum((int)word
->arg
[0])) {
2029 vty_out(vty
, "Please specify string starting with alphabet\n");
2030 return CMD_WARNING_CONFIG_FAILED
;
2033 return cmd_hostname_set(word
->arg
);
2036 DEFUN (config_no_hostname
,
2038 "no hostname [HOSTNAME]",
2040 "Reset system's network name\n"
2041 "Host name of this router\n")
2043 return cmd_hostname_set(NULL
);
2046 /* VTY interface password set. */
2047 DEFUN (config_password
,
2049 "password [(8-8)] WORD",
2050 "Modify the terminal connection password\n"
2051 "Specifies a HIDDEN password will follow\n"
2052 "The password string\n")
2056 if (argc
== 3) // '8' was specified
2059 XFREE(MTYPE_HOST
, host
.password
);
2060 host
.password
= NULL
;
2061 if (host
.password_encrypt
)
2062 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2063 host
.password_encrypt
=
2064 XSTRDUP(MTYPE_HOST
, argv
[idx_word
]->arg
);
2068 if (!isalnum((int)argv
[idx_8
]->arg
[0])) {
2070 "Please specify string starting with alphanumeric\n");
2071 return CMD_WARNING_CONFIG_FAILED
;
2075 XFREE(MTYPE_HOST
, host
.password
);
2076 host
.password
= NULL
;
2079 if (host
.password_encrypt
)
2080 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2081 host
.password_encrypt
=
2082 XSTRDUP(MTYPE_HOST
, zencrypt(argv
[idx_8
]->arg
));
2084 host
.password
= XSTRDUP(MTYPE_HOST
, argv
[idx_8
]->arg
);
2089 /* VTY interface password delete. */
2090 DEFUN (no_config_password
,
2094 "Modify the terminal connection password\n")
2096 bool warned
= false;
2098 if (host
.password
) {
2099 if (!vty_shell_serv(vty
)) {
2100 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
2103 XFREE(MTYPE_HOST
, host
.password
);
2105 host
.password
= NULL
;
2107 if (host
.password_encrypt
) {
2108 if (!warned
&& !vty_shell_serv(vty
))
2109 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
2110 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2112 host
.password_encrypt
= NULL
;
2117 /* VTY enable password set. */
2118 DEFUN (config_enable_password
,
2119 enable_password_cmd
,
2120 "enable password [(8-8)] WORD",
2121 "Modify enable password parameters\n"
2122 "Assign the privileged level password\n"
2123 "Specifies a HIDDEN password will follow\n"
2124 "The HIDDEN 'enable' password string\n")
2129 /* Crypt type is specified. */
2131 if (argv
[idx_8
]->arg
[0] == '8') {
2133 XFREE(MTYPE_HOST
, host
.enable
);
2136 if (host
.enable_encrypt
)
2137 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2138 host
.enable_encrypt
=
2139 XSTRDUP(MTYPE_HOST
, argv
[idx_word
]->arg
);
2143 vty_out(vty
, "Unknown encryption type.\n");
2144 return CMD_WARNING_CONFIG_FAILED
;
2148 if (!isalnum((int)argv
[idx_8
]->arg
[0])) {
2150 "Please specify string starting with alphanumeric\n");
2151 return CMD_WARNING_CONFIG_FAILED
;
2155 XFREE(MTYPE_HOST
, host
.enable
);
2158 /* Plain password input. */
2160 if (host
.enable_encrypt
)
2161 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2162 host
.enable_encrypt
=
2163 XSTRDUP(MTYPE_HOST
, zencrypt(argv
[idx_8
]->arg
));
2165 host
.enable
= XSTRDUP(MTYPE_HOST
, argv
[idx_8
]->arg
);
2170 /* VTY enable password delete. */
2171 DEFUN (no_config_enable_password
,
2172 no_enable_password_cmd
,
2173 "no enable password",
2175 "Modify enable password parameters\n"
2176 "Assign the privileged level password\n")
2178 bool warned
= false;
2181 if (!vty_shell_serv(vty
)) {
2182 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
2185 XFREE(MTYPE_HOST
, host
.enable
);
2189 if (host
.enable_encrypt
) {
2190 if (!warned
&& !vty_shell_serv(vty
))
2191 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
2192 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2194 host
.enable_encrypt
= NULL
;
2199 DEFUN (service_password_encrypt
,
2200 service_password_encrypt_cmd
,
2201 "service password-encryption",
2202 "Set up miscellaneous service\n"
2203 "Enable encrypted passwords\n")
2210 if (host
.password
) {
2211 if (host
.password_encrypt
)
2212 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2213 host
.password_encrypt
=
2214 XSTRDUP(MTYPE_HOST
, zencrypt(host
.password
));
2217 if (host
.enable_encrypt
)
2218 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2219 host
.enable_encrypt
=
2220 XSTRDUP(MTYPE_HOST
, zencrypt(host
.enable
));
2226 DEFUN (no_service_password_encrypt
,
2227 no_service_password_encrypt_cmd
,
2228 "no service password-encryption",
2230 "Set up miscellaneous service\n"
2231 "Enable encrypted passwords\n")
2238 if (host
.password_encrypt
)
2239 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2240 host
.password_encrypt
= NULL
;
2242 if (host
.enable_encrypt
)
2243 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2244 host
.enable_encrypt
= NULL
;
2249 DEFUN (config_terminal_length
,
2250 config_terminal_length_cmd
,
2251 "terminal length (0-512)",
2252 "Set terminal line parameters\n"
2253 "Set number of lines on a screen\n"
2254 "Number of lines on screen (0 for no pausing)\n")
2258 vty
->lines
= atoi(argv
[idx_number
]->arg
);
2263 DEFUN (config_terminal_no_length
,
2264 config_terminal_no_length_cmd
,
2265 "terminal no length",
2266 "Set terminal line parameters\n"
2268 "Set number of lines on a screen\n")
2274 DEFUN (service_terminal_length
,
2275 service_terminal_length_cmd
,
2276 "service terminal-length (0-512)",
2277 "Set up miscellaneous service\n"
2278 "System wide terminal length configuration\n"
2279 "Number of lines of VTY (0 means no line control)\n")
2283 host
.lines
= atoi(argv
[idx_number
]->arg
);
2288 DEFUN (no_service_terminal_length
,
2289 no_service_terminal_length_cmd
,
2290 "no service terminal-length [(0-512)]",
2292 "Set up miscellaneous service\n"
2293 "System wide terminal length configuration\n"
2294 "Number of lines of VTY (0 means no line control)\n")
2300 DEFUN_HIDDEN (do_echo
,
2303 "Echo a message back to the vty\n"
2304 "The message to echo\n")
2308 vty_out(vty
, "%s\n",
2309 ((message
= argv_concat(argv
, argc
, 1)) ? message
: ""));
2311 XFREE(MTYPE_TMP
, message
);
2315 DEFUN (config_logmsg
,
2317 "logmsg <emergencies|alerts|critical|errors|warnings|notifications|informational|debugging> MESSAGE...",
2318 "Send a message to enabled logging destinations\n"
2320 "The message to send\n")
2322 int idx_log_level
= 1;
2323 int idx_message
= 2;
2327 if ((level
= level_match(argv
[idx_log_level
]->arg
)) == ZLOG_DISABLED
)
2328 return CMD_ERR_NO_MATCH
;
2331 ((message
= argv_concat(argv
, argc
, idx_message
)) ? message
: ""));
2333 XFREE(MTYPE_TMP
, message
);
2338 DEFUN (show_logging
,
2342 "Show current logging configuration\n")
2344 struct zlog
*zl
= zlog_default
;
2346 vty_out(vty
, "Syslog logging: ");
2347 if (zl
->maxlvl
[ZLOG_DEST_SYSLOG
] == ZLOG_DISABLED
)
2348 vty_out(vty
, "disabled");
2350 vty_out(vty
, "level %s, facility %s, ident %s",
2351 zlog_priority
[zl
->maxlvl
[ZLOG_DEST_SYSLOG
]],
2352 facility_name(zl
->facility
), zl
->ident
);
2355 vty_out(vty
, "Stdout logging: ");
2356 if (zl
->maxlvl
[ZLOG_DEST_STDOUT
] == ZLOG_DISABLED
)
2357 vty_out(vty
, "disabled");
2359 vty_out(vty
, "level %s",
2360 zlog_priority
[zl
->maxlvl
[ZLOG_DEST_STDOUT
]]);
2363 vty_out(vty
, "Monitor logging: ");
2364 if (zl
->maxlvl
[ZLOG_DEST_MONITOR
] == ZLOG_DISABLED
)
2365 vty_out(vty
, "disabled");
2367 vty_out(vty
, "level %s",
2368 zlog_priority
[zl
->maxlvl
[ZLOG_DEST_MONITOR
]]);
2371 vty_out(vty
, "File logging: ");
2372 if ((zl
->maxlvl
[ZLOG_DEST_FILE
] == ZLOG_DISABLED
) || !zl
->fp
)
2373 vty_out(vty
, "disabled");
2375 vty_out(vty
, "level %s, filename %s",
2376 zlog_priority
[zl
->maxlvl
[ZLOG_DEST_FILE
]],
2380 vty_out(vty
, "Protocol name: %s\n", zl
->protoname
);
2381 vty_out(vty
, "Record priority: %s\n",
2382 (zl
->record_priority
? "enabled" : "disabled"));
2383 vty_out(vty
, "Timestamp precision: %d\n", zl
->timestamp_precision
);
2388 DEFUN (config_log_stdout
,
2389 config_log_stdout_cmd
,
2390 "log stdout [<emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>]",
2392 "Set stdout logging level\n"
2395 int idx_log_level
= 2;
2397 if (argc
== idx_log_level
) {
2398 zlog_set_level(ZLOG_DEST_STDOUT
, zlog_default
->default_lvl
);
2403 if ((level
= level_match(argv
[idx_log_level
]->arg
)) == ZLOG_DISABLED
)
2404 return CMD_ERR_NO_MATCH
;
2405 zlog_set_level(ZLOG_DEST_STDOUT
, level
);
2409 DEFUN (no_config_log_stdout
,
2410 no_config_log_stdout_cmd
,
2411 "no log stdout [<emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>]",
2414 "Cancel logging to stdout\n"
2417 zlog_set_level(ZLOG_DEST_STDOUT
, ZLOG_DISABLED
);
2421 DEFUN (config_log_monitor
,
2422 config_log_monitor_cmd
,
2423 "log monitor [<emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>]",
2425 "Set terminal line (monitor) logging level\n"
2428 int idx_log_level
= 2;
2430 if (argc
== idx_log_level
) {
2431 zlog_set_level(ZLOG_DEST_MONITOR
, zlog_default
->default_lvl
);
2436 if ((level
= level_match(argv
[idx_log_level
]->arg
)) == ZLOG_DISABLED
)
2437 return CMD_ERR_NO_MATCH
;
2438 zlog_set_level(ZLOG_DEST_MONITOR
, level
);
2442 DEFUN (no_config_log_monitor
,
2443 no_config_log_monitor_cmd
,
2444 "no log monitor [<emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>]",
2447 "Disable terminal line (monitor) logging\n"
2450 zlog_set_level(ZLOG_DEST_MONITOR
, ZLOG_DISABLED
);
2454 static int set_log_file(struct vty
*vty
, const char *fname
, int loglevel
)
2458 const char *fullpath
;
2460 /* Path detection. */
2461 if (!IS_DIRECTORY_SEP(*fname
)) {
2462 char cwd
[MAXPATHLEN
+ 1];
2463 cwd
[MAXPATHLEN
] = '\0';
2465 if (getcwd(cwd
, MAXPATHLEN
) == NULL
) {
2466 flog_err_sys(EC_LIB_SYSTEM_CALL
,
2467 "config_log_file: Unable to alloc mem!");
2468 return CMD_WARNING_CONFIG_FAILED
;
2471 p
= XMALLOC(MTYPE_TMP
, strlen(cwd
) + strlen(fname
) + 2);
2472 sprintf(p
, "%s/%s", cwd
, fname
);
2477 ret
= zlog_set_file(fullpath
, loglevel
);
2480 XFREE(MTYPE_TMP
, p
);
2484 vty_out(vty
, "can't open logfile %s\n", fname
);
2485 return CMD_WARNING_CONFIG_FAILED
;
2489 XFREE(MTYPE_HOST
, host
.logfile
);
2491 host
.logfile
= XSTRDUP(MTYPE_HOST
, fname
);
2493 #if defined(HAVE_CUMULUS)
2494 if (zlog_default
->maxlvl
[ZLOG_DEST_SYSLOG
] != ZLOG_DISABLED
)
2495 zlog_set_level(ZLOG_DEST_SYSLOG
, ZLOG_DISABLED
);
2500 void command_setup_early_logging(const char *dest
, const char *level
)
2505 int nlevel
= level_match(level
);
2507 if (nlevel
!= ZLOG_DISABLED
)
2508 zlog_default
->default_lvl
= nlevel
;
2514 if (strcmp(dest
, "stdout") == 0) {
2515 zlog_set_level(ZLOG_DEST_STDOUT
, zlog_default
->default_lvl
);
2519 if (strcmp(dest
, "syslog") == 0) {
2520 zlog_set_level(ZLOG_DEST_SYSLOG
, zlog_default
->default_lvl
);
2524 token
= strstr(dest
, ":");
2530 set_log_file(NULL
, token
, zlog_default
->default_lvl
);
2533 DEFUN (config_log_file
,
2534 config_log_file_cmd
,
2535 "log file FILENAME [<emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>]",
2538 "Logging filename\n"
2541 int idx_filename
= 2;
2542 int idx_log_levels
= 3;
2545 if ((level
= level_match(argv
[idx_log_levels
]->arg
))
2547 return CMD_ERR_NO_MATCH
;
2548 return set_log_file(vty
, argv
[idx_filename
]->arg
, level
);
2550 return set_log_file(vty
, argv
[idx_filename
]->arg
,
2551 zlog_default
->default_lvl
);
2554 static void disable_log_file(void)
2559 XFREE(MTYPE_HOST
, host
.logfile
);
2561 host
.logfile
= NULL
;
2564 DEFUN (no_config_log_file
,
2565 no_config_log_file_cmd
,
2566 "no log file [FILENAME [LEVEL]]",
2569 "Cancel logging to file\n"
2570 "Logging file name\n"
2577 DEFUN (config_log_syslog
,
2578 config_log_syslog_cmd
,
2579 "log syslog [<emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>]",
2581 "Set syslog logging level\n"
2584 int idx_log_levels
= 2;
2590 if ((level
= level_match(argv
[idx_log_levels
]->arg
))
2592 return CMD_ERR_NO_MATCH
;
2593 zlog_set_level(ZLOG_DEST_SYSLOG
, level
);
2596 zlog_set_level(ZLOG_DEST_SYSLOG
, zlog_default
->default_lvl
);
2601 DEFUN (no_config_log_syslog
,
2602 no_config_log_syslog_cmd
,
2603 "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>]",
2606 "Cancel logging to syslog\n"
2610 zlog_set_level(ZLOG_DEST_SYSLOG
, ZLOG_DISABLED
);
2614 DEFUN (config_log_facility
,
2615 config_log_facility_cmd
,
2616 "log facility <kern|user|mail|daemon|auth|syslog|lpr|news|uucp|cron|local0|local1|local2|local3|local4|local5|local6|local7>",
2618 "Facility parameter for syslog messages\n"
2622 int facility
= facility_match(argv
[idx_target
]->arg
);
2624 zlog_default
->facility
= facility
;
2628 DEFUN (no_config_log_facility
,
2629 no_config_log_facility_cmd
,
2630 "no log facility [<kern|user|mail|daemon|auth|syslog|lpr|news|uucp|cron|local0|local1|local2|local3|local4|local5|local6|local7>]",
2633 "Reset syslog facility to default (daemon)\n"
2636 zlog_default
->facility
= LOG_DAEMON
;
2640 DEFUN (config_log_record_priority
,
2641 config_log_record_priority_cmd
,
2642 "log record-priority",
2644 "Log the priority of the message within the message\n")
2646 zlog_default
->record_priority
= 1;
2650 DEFUN (no_config_log_record_priority
,
2651 no_config_log_record_priority_cmd
,
2652 "no log record-priority",
2655 "Do not log the priority of the message within the message\n")
2657 zlog_default
->record_priority
= 0;
2661 DEFUN (config_log_timestamp_precision
,
2662 config_log_timestamp_precision_cmd
,
2663 "log timestamp precision (0-6)",
2665 "Timestamp configuration\n"
2666 "Set the timestamp precision\n"
2667 "Number of subsecond digits\n")
2670 zlog_default
->timestamp_precision
=
2671 strtoul(argv
[idx_number
]->arg
, NULL
, 10);
2675 DEFUN (no_config_log_timestamp_precision
,
2676 no_config_log_timestamp_precision_cmd
,
2677 "no log timestamp precision",
2680 "Timestamp configuration\n"
2681 "Reset the timestamp precision to the default value of 0\n")
2683 zlog_default
->timestamp_precision
= 0;
2687 DEFUN (debug_memstats
,
2689 "[no] debug memstats-at-exit",
2692 "Print memory type statistics at exit\n")
2694 debug_memstats_at_exit
= !!strcmp(argv
[0]->text
, "no");
2698 int cmd_banner_motd_file(const char *file
)
2700 int success
= CMD_SUCCESS
;
2705 rpath
= realpath(file
, p
);
2707 return CMD_ERR_NO_FILE
;
2708 in
= strstr(rpath
, SYSCONFDIR
);
2711 XFREE(MTYPE_HOST
, host
.motdfile
);
2712 host
.motdfile
= XSTRDUP(MTYPE_HOST
, file
);
2714 success
= CMD_WARNING_CONFIG_FAILED
;
2719 DEFUN (banner_motd_file
,
2720 banner_motd_file_cmd
,
2721 "banner motd file FILE",
2724 "Banner from a file\n"
2728 const char *filename
= argv
[idx_file
]->arg
;
2729 int cmd
= cmd_banner_motd_file(filename
);
2731 if (cmd
== CMD_ERR_NO_FILE
)
2732 vty_out(vty
, "%s does not exist", filename
);
2733 else if (cmd
== CMD_WARNING_CONFIG_FAILED
)
2734 vty_out(vty
, "%s must be in %s", filename
, SYSCONFDIR
);
2739 DEFUN (banner_motd_default
,
2740 banner_motd_default_cmd
,
2741 "banner motd default",
2742 "Set banner string\n"
2743 "Strings for motd\n"
2746 host
.motd
= default_motd
;
2750 DEFUN (no_banner_motd
,
2754 "Set banner string\n"
2755 "Strings for motd\n")
2759 XFREE(MTYPE_HOST
, host
.motdfile
);
2760 host
.motdfile
= NULL
;
2767 "Find CLI command containing text\n"
2768 "Text to search for\n")
2770 char *text
= argv_concat(argv
, argc
, 1);
2771 const struct cmd_node
*node
;
2772 const struct cmd_element
*cli
;
2775 for (unsigned int i
= 0; i
< vector_active(cmdvec
); i
++) {
2776 node
= vector_slot(cmdvec
, i
);
2779 clis
= node
->cmd_vector
;
2780 for (unsigned int j
= 0; j
< vector_active(clis
); j
++) {
2781 cli
= vector_slot(clis
, j
);
2782 if (strcasestr(cli
->string
, text
))
2783 vty_out(vty
, " (%s) %s\n",
2784 node_names
[node
->node
], cli
->string
);
2788 XFREE(MTYPE_TMP
, text
);
2793 /* Set config filename. Called from vty.c */
2794 void host_config_set(const char *filename
)
2797 XFREE(MTYPE_HOST
, host
.config
);
2798 host
.config
= XSTRDUP(MTYPE_HOST
, filename
);
2801 const char *host_config_get(void)
2806 void install_default(enum node_type node
)
2808 install_element(node
, &config_exit_cmd
);
2809 install_element(node
, &config_quit_cmd
);
2810 install_element(node
, &config_end_cmd
);
2811 install_element(node
, &config_help_cmd
);
2812 install_element(node
, &config_list_cmd
);
2813 install_element(node
, &show_cli_graph_cmd
);
2814 install_element(node
, &find_cmd
);
2816 install_element(node
, &config_write_cmd
);
2817 install_element(node
, &show_running_config_cmd
);
2819 install_element(node
, &autocomplete_cmd
);
2821 nb_cli_install_default(node
);
2824 /* Initialize command interface. Install basic nodes and commands.
2826 * terminal = 0 -- vtysh / no logging, no config control
2827 * terminal = 1 -- normal daemon
2828 * terminal = -1 -- watchfrr / no logging, but minimal config control */
2829 void cmd_init(int terminal
)
2831 struct utsname names
;
2833 if (array_size(node_names
) != NODE_TYPE_MAX
)
2834 assert(!"Update the CLI node description array!");
2839 /* register command preprocessors */
2840 hook_register(cmd_execute
, handle_pipe_action
);
2841 hook_register(cmd_execute_done
, handle_pipe_action_done
);
2843 varhandlers
= list_new();
2845 /* Allocate initial top vector of commands. */
2846 cmdvec
= vector_init(VECTOR_MIN_SIZE
);
2848 /* Default host value settings. */
2849 host
.name
= XSTRDUP(MTYPE_HOST
, names
.nodename
);
2850 #ifdef HAVE_STRUCT_UTSNAME_DOMAINNAME
2851 if ((strcmp(names
.domainname
, "(none)") == 0))
2852 host
.domainname
= NULL
;
2854 host
.domainname
= XSTRDUP(MTYPE_HOST
, names
.domainname
);
2856 host
.domainname
= NULL
;
2858 host
.password
= NULL
;
2860 host
.logfile
= NULL
;
2862 host
.noconfig
= (terminal
< 0);
2864 host
.motd
= default_motd
;
2865 host
.motdfile
= NULL
;
2867 /* Install top nodes. */
2868 install_node(&view_node
, NULL
);
2869 install_node(&enable_node
, NULL
);
2870 install_node(&auth_node
, NULL
);
2871 install_node(&auth_enable_node
, NULL
);
2872 install_node(&config_node
, config_write_host
);
2874 /* Each node's basic commands. */
2875 install_element(VIEW_NODE
, &show_version_cmd
);
2876 install_element(ENABLE_NODE
, &show_startup_config_cmd
);
2877 install_element(ENABLE_NODE
, &debug_memstats_cmd
);
2880 install_element(VIEW_NODE
, &config_list_cmd
);
2881 install_element(VIEW_NODE
, &config_exit_cmd
);
2882 install_element(VIEW_NODE
, &config_quit_cmd
);
2883 install_element(VIEW_NODE
, &config_help_cmd
);
2884 install_element(VIEW_NODE
, &config_enable_cmd
);
2885 install_element(VIEW_NODE
, &config_terminal_length_cmd
);
2886 install_element(VIEW_NODE
, &config_terminal_no_length_cmd
);
2887 install_element(VIEW_NODE
, &show_logging_cmd
);
2888 install_element(VIEW_NODE
, &show_commandtree_cmd
);
2889 install_element(VIEW_NODE
, &echo_cmd
);
2890 install_element(VIEW_NODE
, &autocomplete_cmd
);
2891 install_element(VIEW_NODE
, &find_cmd
);
2893 install_element(ENABLE_NODE
, &config_end_cmd
);
2894 install_element(ENABLE_NODE
, &config_disable_cmd
);
2895 install_element(ENABLE_NODE
, &config_terminal_cmd
);
2896 install_element(ENABLE_NODE
, ©_runningconf_startupconf_cmd
);
2897 install_element(ENABLE_NODE
, &config_write_cmd
);
2898 install_element(ENABLE_NODE
, &show_running_config_cmd
);
2899 install_element(ENABLE_NODE
, &config_logmsg_cmd
);
2901 install_default(CONFIG_NODE
);
2904 workqueue_cmd_init();
2908 install_element(CONFIG_NODE
, &hostname_cmd
);
2909 install_element(CONFIG_NODE
, &no_hostname_cmd
);
2910 install_element(CONFIG_NODE
, &domainname_cmd
);
2911 install_element(CONFIG_NODE
, &no_domainname_cmd
);
2912 install_element(CONFIG_NODE
, &frr_version_defaults_cmd
);
2913 install_element(CONFIG_NODE
, &debug_memstats_cmd
);
2916 install_element(CONFIG_NODE
, &password_cmd
);
2917 install_element(CONFIG_NODE
, &no_password_cmd
);
2918 install_element(CONFIG_NODE
, &enable_password_cmd
);
2919 install_element(CONFIG_NODE
, &no_enable_password_cmd
);
2921 install_element(CONFIG_NODE
, &config_log_stdout_cmd
);
2922 install_element(CONFIG_NODE
, &no_config_log_stdout_cmd
);
2923 install_element(CONFIG_NODE
, &config_log_monitor_cmd
);
2924 install_element(CONFIG_NODE
, &no_config_log_monitor_cmd
);
2925 install_element(CONFIG_NODE
, &config_log_file_cmd
);
2926 install_element(CONFIG_NODE
, &no_config_log_file_cmd
);
2927 install_element(CONFIG_NODE
, &config_log_syslog_cmd
);
2928 install_element(CONFIG_NODE
, &no_config_log_syslog_cmd
);
2929 install_element(CONFIG_NODE
, &config_log_facility_cmd
);
2930 install_element(CONFIG_NODE
, &no_config_log_facility_cmd
);
2931 install_element(CONFIG_NODE
, &config_log_record_priority_cmd
);
2932 install_element(CONFIG_NODE
,
2933 &no_config_log_record_priority_cmd
);
2934 install_element(CONFIG_NODE
,
2935 &config_log_timestamp_precision_cmd
);
2936 install_element(CONFIG_NODE
,
2937 &no_config_log_timestamp_precision_cmd
);
2938 install_element(CONFIG_NODE
, &service_password_encrypt_cmd
);
2939 install_element(CONFIG_NODE
, &no_service_password_encrypt_cmd
);
2940 install_element(CONFIG_NODE
, &banner_motd_default_cmd
);
2941 install_element(CONFIG_NODE
, &banner_motd_file_cmd
);
2942 install_element(CONFIG_NODE
, &no_banner_motd_cmd
);
2943 install_element(CONFIG_NODE
, &service_terminal_length_cmd
);
2944 install_element(CONFIG_NODE
, &no_service_terminal_length_cmd
);
2946 vrf_install_commands();
2950 grammar_sandbox_init();
2954 void cmd_terminate()
2956 struct cmd_node
*cmd_node
;
2958 hook_unregister(cmd_execute
, handle_pipe_action
);
2959 hook_unregister(cmd_execute_done
, handle_pipe_action_done
);
2962 for (unsigned int i
= 0; i
< vector_active(cmdvec
); i
++)
2963 if ((cmd_node
= vector_slot(cmdvec
, i
)) != NULL
) {
2964 // deleting the graph delets the cmd_element as
2966 graph_delete_graph(cmd_node
->cmdgraph
);
2967 vector_free(cmd_node
->cmd_vector
);
2968 hash_clean(cmd_node
->cmd_hash
, NULL
);
2969 hash_free(cmd_node
->cmd_hash
);
2970 cmd_node
->cmd_hash
= NULL
;
2973 vector_free(cmdvec
);
2978 XFREE(MTYPE_HOST
, host
.name
);
2979 if (host
.domainname
)
2980 XFREE(MTYPE_HOST
, host
.domainname
);
2982 XFREE(MTYPE_HOST
, host
.password
);
2983 if (host
.password_encrypt
)
2984 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2986 XFREE(MTYPE_HOST
, host
.enable
);
2987 if (host
.enable_encrypt
)
2988 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2990 XFREE(MTYPE_HOST
, host
.logfile
);
2992 XFREE(MTYPE_HOST
, host
.motdfile
);
2994 XFREE(MTYPE_HOST
, host
.config
);
2996 list_delete(&varhandlers
);