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"
49 DEFINE_MTYPE(LIB
, HOST
, "Host config")
50 DEFINE_MTYPE(LIB
, COMPLETION
, "Completion item")
57 /* clang-format off */
58 const struct message tokennames
[] = {
63 item(IPV4_PREFIX_TKN
),
65 item(IPV6_PREFIX_TKN
),
75 const char *node_names
[] = {
78 "auth enable", // AUTH_ENABLE_NODE,
79 "enable", // ENABLE_NODE,
80 "config", // CONFIG_NODE,
81 "debug", // DEBUG_NODE,
82 "vrf debug", // VRF_DEBUG_NODE,
83 "vnc debug", // DEBUG_VNC_NODE,
85 "keychain", // KEYCHAIN_NODE,
86 "keychain key", // KEYCHAIN_KEY_NODE,
87 "logical-router", // LOGICALROUTER_NODE,
88 "static ip", // IP_NODE,
90 "interface", // INTERFACE_NODE,
91 "nexthop-group", // NH_GROUP_NODE,
92 "zebra", // ZEBRA_NODE,
93 "table", // TABLE_NODE,
95 "ripng", // RIPNG_NODE,
96 "babel", // BABEL_NODE,
97 "eigrp", // EIGRP_NODE,
99 "bgp vpnv4", // BGP_VPNV4_NODE,
100 "bgp vpnv6", // BGP_VPNV6_NODE,
101 "bgp ipv4 unicast", // BGP_IPV4_NODE,
102 "bgp ipv4 multicast", // BGP_IPV4M_NODE,
103 "bgp ipv4 labeled unicast", // BGP_IPV4L_NODE,
104 "bgp ipv6", // BGP_IPV6_NODE,
105 "bgp ipv6 multicast", // BGP_IPV6M_NODE,
106 "bgp ipv6 labeled unicast", // BGP_IPV6L_NODE,
107 "bgp vrf policy", // BGP_VRF_POLICY_NODE,
108 "bgp vnc defaults", // BGP_VNC_DEFAULTS_NODE,
109 "bgp vnc nve", // BGP_VNC_NVE_GROUP_NODE,
110 "bgp vnc l2", // BGP_VNC_L2_GROUP_NODE,
111 "rfp defaults", // RFP_DEFAULTS_NODE,
112 "bgp evpn", // BGP_EVPN_NODE,
113 "ospf", // OSPF_NODE,
114 "ospf6", // OSPF6_NODE,
116 "ldp ipv4", // LDP_IPV4_NODE,
117 "ldp ipv6", // LDP_IPV6_NODE,
118 "ldp ipv4 interface", // LDP_IPV4_IFACE_NODE,
119 "ldp ipv6 interface", // LDP_IPV6_IFACE_NODE,
120 "ldp l2vpn", // LDP_L2VPN_NODE,
121 "ldp", // LDP_PSEUDOWIRE_NODE,
122 "isis", // ISIS_NODE,
123 "ipv4 access list", // ACCESS_NODE,
124 "ipv4 prefix list", // PREFIX_NODE,
125 "ipv6 access list", // ACCESS_IPV6_NODE,
126 "MAC access list", // ACCESS_MAC_NODE,
127 "ipv6 prefix list", // PREFIX_IPV6_NODE,
128 "as list", // AS_LIST_NODE,
129 "community list", // COMMUNITY_LIST_NODE,
130 "routemap", // RMAP_NODE,
131 "pbr-map", // PBRMAP_NODE,
132 "smux", // SMUX_NODE,
133 "dump", // DUMP_NODE,
134 "forwarding", // FORWARDING_NODE,
135 "protocol", // PROTOCOL_NODE,
136 "mpls", // MPLS_NODE,
139 "link-params", // LINK_PARAMS_NODE,
140 "bgp evpn vni", // BGP_EVPN_VNI_NODE,
142 "bgp ipv4 flowspec", /* BGP_FLOWSPECV4_NODE
144 "bgp ipv6 flowspec", /* BGP_FLOWSPECV6_NODE
147 /* clang-format on */
149 /* Command vector which includes some level of command lists. Normally
150 each daemon maintains each own cmdvec. */
151 vector cmdvec
= NULL
;
153 /* Host information structure. */
157 * Returns host.name if any, otherwise
158 * it returns the system hostname.
160 const char *cmd_hostname_get(void)
166 * Returns unix domainname
168 const char *cmd_domainname_get(void)
170 return host
.domainname
;
173 /* Standard command node structures. */
174 static struct cmd_node auth_node
= {
175 AUTH_NODE
, "Password: ",
178 static struct cmd_node view_node
= {
182 static struct cmd_node auth_enable_node
= {
183 AUTH_ENABLE_NODE
, "Password: ",
186 static struct cmd_node enable_node
= {
190 static struct cmd_node config_node
= {CONFIG_NODE
, "%s(config)# ", 1};
192 /* Default motd string. */
193 static const char *default_motd
= FRR_DEFAULT_MOTD
;
195 static const struct facility_map
{
199 } syslog_facilities
[] = {
200 {LOG_KERN
, "kern", 1},
201 {LOG_USER
, "user", 2},
202 {LOG_MAIL
, "mail", 1},
203 {LOG_DAEMON
, "daemon", 1},
204 {LOG_AUTH
, "auth", 1},
205 {LOG_SYSLOG
, "syslog", 1},
207 {LOG_NEWS
, "news", 1},
208 {LOG_UUCP
, "uucp", 2},
209 {LOG_CRON
, "cron", 1},
213 {LOG_LOCAL0
, "local0", 6},
214 {LOG_LOCAL1
, "local1", 6},
215 {LOG_LOCAL2
, "local2", 6},
216 {LOG_LOCAL3
, "local3", 6},
217 {LOG_LOCAL4
, "local4", 6},
218 {LOG_LOCAL5
, "local5", 6},
219 {LOG_LOCAL6
, "local6", 6},
220 {LOG_LOCAL7
, "local7", 6},
224 static const char *facility_name(int facility
)
226 const struct facility_map
*fm
;
228 for (fm
= syslog_facilities
; fm
->name
; fm
++)
229 if (fm
->facility
== facility
)
234 static int facility_match(const char *str
)
236 const struct facility_map
*fm
;
238 for (fm
= syslog_facilities
; fm
->name
; fm
++)
239 if (!strncmp(str
, fm
->name
, fm
->match
))
244 static int level_match(const char *s
)
248 for (level
= 0; zlog_priority
[level
] != NULL
; level
++)
249 if (!strncmp(s
, zlog_priority
[level
], 2))
251 return ZLOG_DISABLED
;
254 /* This is called from main when a daemon is invoked with -v or --version. */
255 void print_version(const char *progname
)
257 printf("%s version %s\n", progname
, FRR_VERSION
);
258 printf("%s\n", FRR_COPYRIGHT
);
259 printf("configured with:\n\t%s\n", FRR_CONFIG_ARGS
);
262 char *argv_concat(struct cmd_token
**argv
, int argc
, int shift
)
264 int cnt
= argc
- shift
;
265 const char *argstr
[cnt
];
267 for (int i
= 0; i
< cnt
; i
++)
268 argstr
[i
] = argv
[i
+ shift
]->arg
;
270 return frrstr_join(argstr
, cnt
, " ");
273 vector
cmd_make_strvec(const char *string
)
278 const char *copy
= string
;
280 /* skip leading whitespace */
281 while (isspace((int)*copy
) && *copy
!= '\0')
284 /* if the entire string was whitespace or a comment, return */
285 if (*copy
== '\0' || *copy
== '!' || *copy
== '#')
288 vector result
= frrstr_split_vec(copy
, "\n\r\t ");
290 for (unsigned int i
= 0; i
< vector_active(result
); i
++) {
291 if (strlen(vector_slot(result
, i
)) == 0) {
292 XFREE(MTYPE_TMP
, vector_slot(result
, i
));
293 vector_unset(result
, i
);
297 vector_compact(result
);
302 void cmd_free_strvec(vector v
)
304 frrstr_strvec_free(v
);
308 * Convenience function for accessing argv data.
312 * @param text definition snippet of the desired token
313 * @param index the starting index, and where to store the
314 * index of the found token if it exists
315 * @return 1 if found, 0 otherwise
317 int argv_find(struct cmd_token
**argv
, int argc
, const char *text
, int *index
)
320 for (int i
= *index
; i
< argc
&& found
== 0; i
++)
321 if ((found
= strmatch(text
, argv
[i
]->text
)))
326 static unsigned int cmd_hash_key(void *p
)
328 int size
= sizeof(p
);
330 return jhash(p
, size
, 0);
333 static int cmd_hash_cmp(const void *a
, const void *b
)
338 /* Install top node of command vector. */
339 void install_node(struct cmd_node
*node
, int (*func
)(struct vty
*))
341 vector_set_index(cmdvec
, node
->node
, node
);
343 node
->cmdgraph
= graph_new();
344 node
->cmd_vector
= vector_init(VECTOR_MIN_SIZE
);
346 struct cmd_token
*token
=
347 cmd_token_new(START_TKN
, CMD_ATTR_NORMAL
, NULL
, NULL
);
348 graph_new_node(node
->cmdgraph
, token
,
349 (void (*)(void *)) & cmd_token_del
);
350 node
->cmd_hash
= hash_create_size(16, cmd_hash_key
, cmd_hash_cmp
,
354 /* Return prompt character of specified node. */
355 const char *cmd_prompt(enum node_type node
)
357 struct cmd_node
*cnode
;
359 cnode
= vector_slot(cmdvec
, node
);
360 return cnode
->prompt
;
363 /* Install a command into a node. */
364 void install_element(enum node_type ntype
, struct cmd_element
*cmd
)
366 struct cmd_node
*cnode
;
368 /* cmd_init hasn't been called */
370 fprintf(stderr
, "%s called before cmd_init, breakage likely\n",
375 cnode
= vector_lookup(cmdvec
, ntype
);
380 "\tnode %d (%s) does not exist.\n"
381 "\tplease call install_node() before install_element()\n",
382 cmd
->name
, cmd
->string
, ntype
, node_names
[ntype
]);
386 if (hash_lookup(cnode
->cmd_hash
, cmd
) != NULL
) {
389 "\tnode %d (%s) already has this command installed.\n"
390 "\tduplicate install_element call?\n",
391 cmd
->name
, cmd
->string
, ntype
, node_names
[ntype
]);
395 assert(hash_get(cnode
->cmd_hash
, cmd
, hash_alloc_intern
));
397 struct graph
*graph
= graph_new();
398 struct cmd_token
*token
=
399 cmd_token_new(START_TKN
, CMD_ATTR_NORMAL
, NULL
, NULL
);
400 graph_new_node(graph
, token
, (void (*)(void *)) & cmd_token_del
);
402 cmd_graph_parse(graph
, cmd
);
403 cmd_graph_names(graph
);
404 cmd_graph_merge(cnode
->cmdgraph
, graph
, +1);
405 graph_delete_graph(graph
);
407 vector_set(cnode
->cmd_vector
, cmd
);
409 if (ntype
== VIEW_NODE
)
410 install_element(ENABLE_NODE
, cmd
);
413 void uninstall_element(enum node_type ntype
, struct cmd_element
*cmd
)
415 struct cmd_node
*cnode
;
417 /* cmd_init hasn't been called */
419 fprintf(stderr
, "%s called before cmd_init, breakage likely\n",
424 cnode
= vector_lookup(cmdvec
, ntype
);
429 "\tnode %d (%s) does not exist.\n"
430 "\tplease call install_node() before uninstall_element()\n",
431 cmd
->name
, cmd
->string
, ntype
, node_names
[ntype
]);
435 if (hash_release(cnode
->cmd_hash
, cmd
) == NULL
) {
438 "\tnode %d (%s) does not have this command installed.\n"
439 "\tduplicate uninstall_element call?\n",
440 cmd
->name
, cmd
->string
, ntype
, node_names
[ntype
]);
444 vector_unset_value(cnode
->cmd_vector
, cmd
);
446 struct graph
*graph
= graph_new();
447 struct cmd_token
*token
=
448 cmd_token_new(START_TKN
, CMD_ATTR_NORMAL
, NULL
, NULL
);
449 graph_new_node(graph
, token
, (void (*)(void *)) & cmd_token_del
);
451 cmd_graph_parse(graph
, cmd
);
452 cmd_graph_names(graph
);
453 cmd_graph_merge(cnode
->cmdgraph
, graph
, -1);
454 graph_delete_graph(graph
);
456 if (ntype
== VIEW_NODE
)
457 uninstall_element(ENABLE_NODE
, cmd
);
461 static const unsigned char itoa64
[] =
462 "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
464 static void to64(char *s
, long v
, int n
)
467 *s
++ = itoa64
[v
& 0x3f];
472 static char *zencrypt(const char *passwd
)
476 char *crypt(const char *, const char *);
478 gettimeofday(&tv
, 0);
480 to64(&salt
[0], random(), 3);
481 to64(&salt
[3], tv
.tv_usec
, 3);
484 return crypt(passwd
, salt
);
487 /* This function write configuration of this host. */
488 static int config_write_host(struct vty
*vty
)
490 if (cmd_hostname_get())
491 vty_out(vty
, "hostname %s\n", cmd_hostname_get());
493 if (cmd_domainname_get())
494 vty_out(vty
, "domainname %s\n", cmd_domainname_get());
496 /* The following are all configuration commands that are not sent to
497 * watchfrr. For instance watchfrr is hardcoded to log to syslog so
498 * we would always display 'log syslog informational' in the config
499 * which would cause other daemons to then switch to syslog when they
502 if (strcmp(zlog_default
->protoname
, "WATCHFRR")) {
504 if (host
.password_encrypt
)
505 vty_out(vty
, "password 8 %s\n",
506 host
.password_encrypt
);
507 if (host
.enable_encrypt
)
508 vty_out(vty
, "enable password 8 %s\n",
509 host
.enable_encrypt
);
512 vty_out(vty
, "password %s\n", host
.password
);
514 vty_out(vty
, "enable password %s\n",
518 if (zlog_default
->default_lvl
!= LOG_DEBUG
) {
520 "! N.B. The 'log trap' command is deprecated.\n");
521 vty_out(vty
, "log trap %s\n",
522 zlog_priority
[zlog_default
->default_lvl
]);
526 && (zlog_default
->maxlvl
[ZLOG_DEST_FILE
]
528 vty_out(vty
, "log file %s", host
.logfile
);
529 if (zlog_default
->maxlvl
[ZLOG_DEST_FILE
]
530 != zlog_default
->default_lvl
)
533 [zlog_default
->maxlvl
538 if (zlog_default
->maxlvl
[ZLOG_DEST_STDOUT
] != ZLOG_DISABLED
) {
539 vty_out(vty
, "log stdout");
540 if (zlog_default
->maxlvl
[ZLOG_DEST_STDOUT
]
541 != zlog_default
->default_lvl
)
544 [zlog_default
->maxlvl
545 [ZLOG_DEST_STDOUT
]]);
549 if (zlog_default
->maxlvl
[ZLOG_DEST_MONITOR
] == ZLOG_DISABLED
)
550 vty_out(vty
, "no log monitor\n");
551 else if (zlog_default
->maxlvl
[ZLOG_DEST_MONITOR
]
552 != zlog_default
->default_lvl
)
553 vty_out(vty
, "log monitor %s\n",
554 zlog_priority
[zlog_default
->maxlvl
555 [ZLOG_DEST_MONITOR
]]);
557 if (zlog_default
->maxlvl
[ZLOG_DEST_SYSLOG
] != ZLOG_DISABLED
) {
558 vty_out(vty
, "log syslog");
559 if (zlog_default
->maxlvl
[ZLOG_DEST_SYSLOG
]
560 != zlog_default
->default_lvl
)
562 zlog_priority
[zlog_default
->maxlvl
563 [ZLOG_DEST_SYSLOG
]]);
567 if (zlog_default
->facility
!= LOG_DAEMON
)
568 vty_out(vty
, "log facility %s\n",
569 facility_name(zlog_default
->facility
));
571 if (zlog_default
->record_priority
== 1)
572 vty_out(vty
, "log record-priority\n");
574 if (zlog_default
->timestamp_precision
> 0)
575 vty_out(vty
, "log timestamp precision %d\n",
576 zlog_default
->timestamp_precision
);
579 vty_out(vty
, "service advanced-vty\n");
582 vty_out(vty
, "service password-encryption\n");
585 vty_out(vty
, "service terminal-length %d\n",
589 vty_out(vty
, "banner motd file %s\n", host
.motdfile
);
591 vty_out(vty
, "no banner motd\n");
594 if (debug_memstats_at_exit
)
595 vty_out(vty
, "!\ndebug memstats-at-exit\n");
600 /* Utility function for getting command graph. */
601 static struct graph
*cmd_node_graph(vector v
, enum node_type ntype
)
603 struct cmd_node
*cnode
= vector_slot(v
, ntype
);
604 return cnode
->cmdgraph
;
607 static int cmd_try_do_shortcut(enum node_type node
, char *first_word
)
609 if (first_word
!= NULL
&& node
!= AUTH_NODE
&& node
!= VIEW_NODE
610 && node
!= AUTH_ENABLE_NODE
&& 0 == strcmp("do", first_word
))
616 * Compare function for cmd_token.
617 * Used with qsort to sort command completions.
619 static int compare_completions(const void *fst
, const void *snd
)
621 struct cmd_token
*first
= *(struct cmd_token
**)fst
,
622 *secnd
= *(struct cmd_token
**)snd
;
623 return strcmp(first
->text
, secnd
->text
);
627 * Takes a list of completions returned by command_complete,
628 * dedeuplicates them based on both text and description,
629 * sorts them, and returns them as a vector.
631 * @param completions linked list of cmd_token
632 * @return deduplicated and sorted vector with
634 vector
completions_to_vec(struct list
*completions
)
636 vector comps
= vector_init(VECTOR_MIN_SIZE
);
639 struct cmd_token
*token
, *cr
= NULL
;
640 unsigned int i
, exists
;
641 for (ALL_LIST_ELEMENTS_RO(completions
, ln
, token
)) {
642 if (token
->type
== END_TKN
&& (cr
= token
))
645 // linear search for token in completions vector
647 for (i
= 0; i
< vector_active(comps
) && !exists
; i
++) {
648 struct cmd_token
*curr
= vector_slot(comps
, i
);
650 exists
= !strcmp(curr
->text
, token
->text
)
651 && !strcmp(curr
->desc
, token
->desc
);
653 exists
= !strcmp(curr
->text
, token
->text
);
654 #endif /* VTYSH_DEBUG */
658 vector_set(comps
, token
);
662 qsort(comps
->index
, vector_active(comps
), sizeof(void *),
663 &compare_completions
);
665 // make <cr> the first element, if it is present
667 vector_set_index(comps
, vector_active(comps
), NULL
);
668 memmove(comps
->index
+ 1, comps
->index
,
669 (comps
->alloced
- 1) * sizeof(void *));
670 vector_set_index(comps
, 0, cr
);
676 * Generates a vector of cmd_token representing possible completions
677 * on the current input.
679 * @param vline the vectorized input line
680 * @param vty the vty with the node to match on
681 * @param status pointer to matcher status code
682 * @return vector of struct cmd_token * with possible completions
684 static vector
cmd_complete_command_real(vector vline
, struct vty
*vty
,
687 struct list
*completions
;
688 struct graph
*cmdgraph
= cmd_node_graph(cmdvec
, vty
->node
);
690 enum matcher_rv rv
= command_complete(cmdgraph
, vline
, &completions
);
692 if (MATCHER_ERROR(rv
)) {
693 *status
= CMD_ERR_NO_MATCH
;
697 vector comps
= completions_to_vec(completions
);
698 list_delete_and_null(&completions
);
700 // set status code appropriately
701 switch (vector_active(comps
)) {
703 *status
= CMD_ERR_NO_MATCH
;
706 *status
= CMD_COMPLETE_FULL_MATCH
;
709 *status
= CMD_COMPLETE_LIST_MATCH
;
715 vector
cmd_describe_command(vector vline
, struct vty
*vty
, int *status
)
719 if (cmd_try_do_shortcut(vty
->node
, vector_slot(vline
, 0))) {
720 enum node_type onode
;
721 vector shifted_vline
;
725 vty
->node
= ENABLE_NODE
;
726 /* We can try it on enable node, cos' the vty is authenticated
729 shifted_vline
= vector_init(vector_count(vline
));
731 for (index
= 1; index
< vector_active(vline
); index
++) {
732 vector_set_index(shifted_vline
, index
- 1,
733 vector_lookup(vline
, index
));
736 ret
= cmd_complete_command_real(shifted_vline
, vty
, status
);
738 vector_free(shifted_vline
);
743 return cmd_complete_command_real(vline
, vty
, status
);
746 static struct list
*varhandlers
= NULL
;
748 void cmd_variable_complete(struct cmd_token
*token
, const char *arg
,
752 const struct cmd_variable_handler
*cvh
;
756 tmpcomps
= arg
? vector_init(VECTOR_MIN_SIZE
) : comps
;
758 for (ALL_LIST_ELEMENTS_RO(varhandlers
, ln
, cvh
)) {
759 if (cvh
->tokenname
&& strcmp(cvh
->tokenname
, token
->text
))
761 if (cvh
->varname
&& (!token
->varname
762 || strcmp(cvh
->varname
, token
->varname
)))
764 cvh
->completions(tmpcomps
, token
);
772 for (i
= vector_active(tmpcomps
); i
; i
--) {
773 char *item
= vector_slot(tmpcomps
, i
- 1);
774 if (strlen(item
) >= argsz
&& !strncmp(item
, arg
, argsz
))
775 vector_set(comps
, item
);
777 XFREE(MTYPE_COMPLETION
, item
);
779 vector_free(tmpcomps
);
782 #define AUTOCOMP_INDENT 5
784 char *cmd_variable_comp2str(vector comps
, unsigned short cols
)
787 char *buf
= XCALLOC(MTYPE_TMP
, bsz
);
788 int lc
= AUTOCOMP_INDENT
;
789 size_t cs
= AUTOCOMP_INDENT
;
791 snprintf(buf
, bsz
, "%*s", AUTOCOMP_INDENT
, "");
792 for (size_t j
= 0; j
< vector_active(comps
); j
++) {
793 char *item
= vector_slot(comps
, j
);
794 itemlen
= strlen(item
);
796 if (cs
+ itemlen
+ AUTOCOMP_INDENT
+ 3 >= bsz
)
797 buf
= XREALLOC(MTYPE_TMP
, buf
, (bsz
*= 2));
799 if (lc
+ itemlen
+ 1 >= cols
) {
800 cs
+= snprintf(&buf
[cs
], bsz
- cs
, "\n%*s",
801 AUTOCOMP_INDENT
, "");
802 lc
= AUTOCOMP_INDENT
;
805 size_t written
= snprintf(&buf
[cs
], bsz
- cs
, "%s ", item
);
808 XFREE(MTYPE_COMPLETION
, item
);
809 vector_set_index(comps
, j
, NULL
);
814 void cmd_variable_handler_register(const struct cmd_variable_handler
*cvh
)
819 for (; cvh
->completions
; cvh
++)
820 listnode_add(varhandlers
, (void *)cvh
);
823 DEFUN_HIDDEN (autocomplete
,
825 "autocomplete TYPE TEXT VARNAME",
826 "Autocompletion handler (internal, for vtysh)\n"
829 "cmd_token->varname\n")
831 struct cmd_token tok
;
832 vector comps
= vector_init(32);
835 memset(&tok
, 0, sizeof(tok
));
836 tok
.type
= atoi(argv
[1]->arg
);
837 tok
.text
= argv
[2]->arg
;
838 tok
.varname
= argv
[3]->arg
;
839 if (!strcmp(tok
.varname
, "-"))
842 cmd_variable_complete(&tok
, NULL
, comps
);
844 for (i
= 0; i
< vector_active(comps
); i
++) {
845 char *text
= vector_slot(comps
, i
);
846 vty_out(vty
, "%s\n", text
);
847 XFREE(MTYPE_COMPLETION
, text
);
855 * Generate possible tab-completions for the given input. This function only
856 * returns results that would result in a valid command if used as Readline
857 * completions (as is the case in vtysh). For instance, if the passed vline ends
858 * with '4.3.2', the strings 'A.B.C.D' and 'A.B.C.D/M' will _not_ be returned.
860 * @param vline vectorized input line
862 * @param status location to store matcher status code in
863 * @return set of valid strings for use with Readline as tab-completions.
866 char **cmd_complete_command(vector vline
, struct vty
*vty
, int *status
)
869 int original_node
= vty
->node
;
870 vector input_line
= vector_init(vector_count(vline
));
872 // if the first token is 'do' we'll want to execute the command in the
874 int do_shortcut
= cmd_try_do_shortcut(vty
->node
, vector_slot(vline
, 0));
875 vty
->node
= do_shortcut
? ENABLE_NODE
: original_node
;
877 // construct the input line we'll be matching on
878 unsigned int offset
= (do_shortcut
) ? 1 : 0;
879 for (unsigned index
= 0; index
+ offset
< vector_active(vline
); index
++)
880 vector_set_index(input_line
, index
,
881 vector_lookup(vline
, index
+ offset
));
883 // get token completions -- this is a copying operation
884 vector comps
= NULL
, initial_comps
;
885 initial_comps
= cmd_complete_command_real(input_line
, vty
, status
);
887 if (!MATCHER_ERROR(*status
)) {
888 assert(initial_comps
);
889 // filter out everything that is not suitable for a
891 comps
= vector_init(VECTOR_MIN_SIZE
);
892 for (unsigned int i
= 0; i
< vector_active(initial_comps
);
894 struct cmd_token
*token
= vector_slot(initial_comps
, i
);
895 if (token
->type
== WORD_TKN
)
896 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
,
898 else if (IS_VARYING_TOKEN(token
->type
)) {
899 const char *ref
= vector_lookup(
900 vline
, vector_active(vline
) - 1);
901 cmd_variable_complete(token
, ref
, comps
);
904 vector_free(initial_comps
);
906 // since we filtered results, we need to re-set status code
907 switch (vector_active(comps
)) {
909 *status
= CMD_ERR_NO_MATCH
;
912 *status
= CMD_COMPLETE_FULL_MATCH
;
915 *status
= CMD_COMPLETE_LIST_MATCH
;
918 // copy completions text into an array of char*
919 ret
= XMALLOC(MTYPE_TMP
,
920 (vector_active(comps
) + 1) * sizeof(char *));
922 for (i
= 0; i
< vector_active(comps
); i
++) {
923 ret
[i
] = vector_slot(comps
, i
);
925 // set the last element to NULL, because this array is used in
926 // a Readline completion_generator function which expects NULL
927 // as a sentinel value
931 } else if (initial_comps
)
932 vector_free(initial_comps
);
934 // comps should always be null here
937 // free the adjusted input line
938 vector_free(input_line
);
940 // reset vty->node to its original value
941 vty
->node
= original_node
;
946 /* return parent node */
947 /* MUST eventually converge on CONFIG_NODE */
948 enum node_type
node_parent(enum node_type node
)
952 assert(node
> CONFIG_NODE
);
957 case BGP_FLOWSPECV4_NODE
:
958 case BGP_FLOWSPECV6_NODE
:
959 case BGP_VRF_POLICY_NODE
:
960 case BGP_VNC_DEFAULTS_NODE
:
961 case BGP_VNC_NVE_GROUP_NODE
:
962 case BGP_VNC_L2_GROUP_NODE
:
972 case BGP_EVPN_VNI_NODE
:
975 case KEYCHAIN_KEY_NODE
:
978 case LINK_PARAMS_NODE
:
979 ret
= INTERFACE_NODE
;
985 case LDP_IPV4_IFACE_NODE
:
988 case LDP_IPV6_IFACE_NODE
:
991 case LDP_PSEUDOWIRE_NODE
:
992 ret
= LDP_L2VPN_NODE
;
1002 /* Execute command by argument vline vector. */
1003 static int cmd_execute_command_real(vector vline
, enum filter_type filter
,
1005 const struct cmd_element
**cmd
)
1007 struct list
*argv_list
;
1008 enum matcher_rv status
;
1009 const struct cmd_element
*matched_element
= NULL
;
1011 struct graph
*cmdgraph
= cmd_node_graph(cmdvec
, vty
->node
);
1012 status
= command_match(cmdgraph
, vline
, &argv_list
, &matched_element
);
1015 *cmd
= matched_element
;
1017 // if matcher error, return corresponding CMD_ERR
1018 if (MATCHER_ERROR(status
)) {
1020 list_delete_and_null(&argv_list
);
1022 case MATCHER_INCOMPLETE
:
1023 return CMD_ERR_INCOMPLETE
;
1024 case MATCHER_AMBIGUOUS
:
1025 return CMD_ERR_AMBIGUOUS
;
1027 return CMD_ERR_NO_MATCH
;
1031 // build argv array from argv list
1032 struct cmd_token
**argv
= XMALLOC(
1033 MTYPE_TMP
, argv_list
->count
* sizeof(struct cmd_token
*));
1034 struct listnode
*ln
;
1035 struct cmd_token
*token
;
1037 for (ALL_LIST_ELEMENTS_RO(argv_list
, ln
, token
))
1040 int argc
= argv_list
->count
;
1043 if (matched_element
->daemon
)
1044 ret
= CMD_SUCCESS_DAEMON
;
1046 ret
= matched_element
->func(matched_element
, vty
, argc
, argv
);
1048 // delete list and cmd_token's in it
1049 list_delete_and_null(&argv_list
);
1050 XFREE(MTYPE_TMP
, argv
);
1056 * Execute a given command, handling things like "do ..." and checking
1057 * whether the given command might apply at a parent node if doesn't
1058 * apply for the current node.
1060 * @param vline Command line input, vector of char* where each element is
1062 * @param vty The vty context in which the command should be executed.
1063 * @param cmd Pointer where the struct cmd_element of the matched command
1064 * will be stored, if any. May be set to NULL if this info is
1066 * @param vtysh If set != 0, don't lookup the command at parent nodes.
1067 * @return The status of the command that has been executed or an error code
1068 * as to why no command could be executed.
1070 int cmd_execute_command(vector vline
, struct vty
*vty
,
1071 const struct cmd_element
**cmd
, int vtysh
)
1073 int ret
, saved_ret
= 0;
1074 enum node_type onode
, try_node
;
1076 onode
= try_node
= vty
->node
;
1078 if (cmd_try_do_shortcut(vty
->node
, vector_slot(vline
, 0))) {
1079 vector shifted_vline
;
1082 vty
->node
= ENABLE_NODE
;
1083 /* We can try it on enable node, cos' the vty is authenticated
1086 shifted_vline
= vector_init(vector_count(vline
));
1088 for (index
= 1; index
< vector_active(vline
); index
++)
1089 vector_set_index(shifted_vline
, index
- 1,
1090 vector_lookup(vline
, index
));
1092 ret
= cmd_execute_command_real(shifted_vline
, FILTER_RELAXED
,
1095 vector_free(shifted_vline
);
1101 cmd_execute_command_real(vline
, FILTER_RELAXED
, vty
, cmd
);
1106 if (ret
!= CMD_SUCCESS
&& ret
!= CMD_WARNING
1107 && ret
!= CMD_NOT_MY_INSTANCE
&& ret
!= CMD_WARNING_CONFIG_FAILED
) {
1108 /* This assumes all nodes above CONFIG_NODE are childs of
1110 while (vty
->node
> CONFIG_NODE
) {
1111 try_node
= node_parent(try_node
);
1112 vty
->node
= try_node
;
1113 ret
= cmd_execute_command_real(vline
, FILTER_RELAXED
,
1115 if (ret
== CMD_SUCCESS
|| ret
== CMD_WARNING
1116 || ret
== CMD_NOT_MY_INSTANCE
1117 || ret
== CMD_WARNING_CONFIG_FAILED
)
1120 /* no command succeeded, reset the vty to the original node */
1124 /* return command status for original node */
1129 * Execute a given command, matching it strictly against the current node.
1130 * This mode is used when reading config files.
1132 * @param vline Command line input, vector of char* where each element is
1134 * @param vty The vty context in which the command should be executed.
1135 * @param cmd Pointer where the struct cmd_element* of the matched command
1136 * will be stored, if any. May be set to NULL if this info is
1138 * @return The status of the command that has been executed or an error code
1139 * as to why no command could be executed.
1141 int cmd_execute_command_strict(vector vline
, struct vty
*vty
,
1142 const struct cmd_element
**cmd
)
1144 return cmd_execute_command_real(vline
, FILTER_STRICT
, vty
, cmd
);
1148 * Hook for preprocessing command string before executing.
1150 * All subscribers are called with the raw command string that is to be
1151 * executed. If any changes are to be made, a new string should be allocated
1152 * with MTYPE_TMP and *cmd_out updated to point to this new string. The caller
1153 * is then responsible for freeing this string.
1155 * All processing functions must be mutually exclusive in their action, i.e. if
1156 * one subscriber decides to modify the command, all others must not modify it
1157 * when called. Feeding the output of one processing command into a subsequent
1158 * one is not supported.
1160 * This hook is intentionally internal to the command processing system.
1163 * The raw command string.
1166 * The result of any processing.
1168 DECLARE_HOOK(cmd_execute
,
1169 (struct vty
*vty
, const char *cmd_in
, char **cmd_out
),
1170 (vty
, cmd_in
, cmd_out
));
1171 DEFINE_HOOK(cmd_execute
, (struct vty
*vty
, const char *cmd_in
, char **cmd_out
),
1172 (vty
, cmd_in
, cmd_out
));
1174 /* Hook executed after a CLI command. */
1175 DECLARE_KOOH(cmd_execute_done
, (struct vty
*vty
, const char *cmd_exec
),
1177 DEFINE_KOOH(cmd_execute_done
, (struct vty
*vty
, const char *cmd_exec
),
1181 * cmd_execute hook subscriber to handle `|` actions.
1183 static int handle_pipe_action(struct vty
*vty
, const char *cmd_in
,
1187 char *orig
, *working
, *token
;
1188 char *pipe
= strstr(cmd_in
, "| ");
1193 /* duplicate string for processing purposes, not including pipe */
1194 orig
= working
= XSTRDUP(MTYPE_TMP
, pipe
+ 2);
1196 /* retrieve action */
1197 token
= strsep(&working
, " ");
1199 /* match result to known actions */
1200 if (strmatch(token
, "include")) {
1201 /* the remaining text should be a regexp */
1202 char *regexp
= working
;
1205 vty_out(vty
, "%% Need a regexp to filter with\n");
1209 bool succ
= vty_set_include(vty
, regexp
);
1212 vty_out(vty
, "%% Bad regexp '%s'\n", regexp
);
1215 *cmd_out
= XSTRDUP(MTYPE_TMP
, cmd_in
);
1216 *(strstr(*cmd_out
, "|")) = '\0';
1218 vty_out(vty
, "%% Unknown action '%s'\n", token
);
1223 XFREE(MTYPE_TMP
, orig
);
1227 static int handle_pipe_action_done(struct vty
*vty
, const char *cmd_exec
)
1230 vty_set_include(vty
, NULL
);
1235 int cmd_execute(struct vty
*vty
, const char *cmd
,
1236 const struct cmd_element
**matched
, int vtysh
)
1239 char *cmd_out
= NULL
;
1240 const char *cmd_exec
;
1243 hook_call(cmd_execute
, vty
, cmd
, &cmd_out
);
1244 cmd_exec
= cmd_out
? (const char *)cmd_out
: cmd
;
1246 vline
= cmd_make_strvec(cmd_exec
);
1249 ret
= cmd_execute_command(vline
, vty
, matched
, vtysh
);
1250 cmd_free_strvec(vline
);
1255 hook_call(cmd_execute_done
, vty
, cmd_exec
);
1258 XFREE(MTYPE_TMP
, cmd_out
);
1265 * Parse one line of config, walking up the parse tree attempting to find a
1268 * @param vty The vty context in which the command should be executed.
1269 * @param cmd Pointer where the struct cmd_element* of the match command
1270 * will be stored, if any. May be set to NULL if this info is
1272 * @param use_daemon Boolean to control whether or not we match on
1273 * CMD_SUCCESS_DAEMON
1275 * @return The status of the command that has been executed or an error code
1276 * as to why no command could be executed.
1278 int command_config_read_one_line(struct vty
*vty
,
1279 const struct cmd_element
**cmd
, int use_daemon
)
1285 vline
= cmd_make_strvec(vty
->buf
);
1287 /* In case of comment line */
1291 /* Execute configuration command : this is strict match */
1292 ret
= cmd_execute_command_strict(vline
, vty
, cmd
);
1294 // Climb the tree and try the command again at each node
1295 if (!(use_daemon
&& ret
== CMD_SUCCESS_DAEMON
)
1296 && !(!use_daemon
&& ret
== CMD_ERR_NOTHING_TODO
)
1297 && ret
!= CMD_SUCCESS
&& ret
!= CMD_WARNING
1298 && ret
!= CMD_NOT_MY_INSTANCE
&& ret
!= CMD_WARNING_CONFIG_FAILED
1299 && vty
->node
!= CONFIG_NODE
) {
1301 saved_node
= vty
->node
;
1303 while (!(use_daemon
&& ret
== CMD_SUCCESS_DAEMON
)
1304 && !(!use_daemon
&& ret
== CMD_ERR_NOTHING_TODO
)
1305 && ret
!= CMD_SUCCESS
&& ret
!= CMD_WARNING
1306 && vty
->node
> CONFIG_NODE
) {
1307 vty
->node
= node_parent(vty
->node
);
1308 ret
= cmd_execute_command_strict(vline
, vty
, cmd
);
1311 // If climbing the tree did not work then ignore the command and
1312 // stay at the same 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 vty
->node
= saved_node
;
1320 if (ret
!= CMD_SUCCESS
&& ret
!= CMD_WARNING
)
1321 memcpy(vty
->error_buf
, vty
->buf
, VTY_BUFSIZ
);
1323 cmd_free_strvec(vline
);
1328 /* Configuration make from file. */
1329 int config_from_file(struct vty
*vty
, FILE *fp
, unsigned int *line_num
)
1331 int ret
, error_ret
= 0;
1334 while (fgets(vty
->buf
, VTY_BUFSIZ
, fp
)) {
1338 ret
= command_config_read_one_line(vty
, NULL
, 0);
1340 if (ret
!= CMD_SUCCESS
&& ret
!= CMD_WARNING
1341 && ret
!= CMD_ERR_NOTHING_TODO
)
1352 /* Configuration from terminal */
1353 DEFUN (config_terminal
,
1354 config_terminal_cmd
,
1355 "configure terminal",
1356 "Configuration from vty interface\n"
1357 "Configuration terminal\n")
1359 if (vty_config_lock(vty
))
1360 vty
->node
= CONFIG_NODE
;
1362 vty_out(vty
, "VTY configuration is locked by other VTY\n");
1363 return CMD_WARNING_CONFIG_FAILED
;
1368 /* Enable command */
1372 "Turn on privileged mode command\n")
1374 /* If enable password is NULL, change to ENABLE_NODE */
1375 if ((host
.enable
== NULL
&& host
.enable_encrypt
== NULL
)
1376 || vty
->type
== VTY_SHELL_SERV
)
1377 vty
->node
= ENABLE_NODE
;
1379 vty
->node
= AUTH_ENABLE_NODE
;
1384 /* Disable command */
1388 "Turn off privileged mode command\n")
1390 if (vty
->node
== ENABLE_NODE
)
1391 vty
->node
= VIEW_NODE
;
1395 /* Down vty node level. */
1399 "Exit current mode and down to previous mode\n")
1405 void cmd_exit(struct vty
*vty
)
1407 switch (vty
->node
) {
1413 vty
->status
= VTY_CLOSE
;
1416 vty
->node
= ENABLE_NODE
;
1417 vty_config_unlock(vty
);
1419 case INTERFACE_NODE
:
1421 case LOGICALROUTER_NODE
:
1433 case LDP_L2VPN_NODE
:
1439 vty
->node
= CONFIG_NODE
;
1442 case BGP_IPV4M_NODE
:
1443 case BGP_IPV4L_NODE
:
1444 case BGP_VPNV4_NODE
:
1445 case BGP_VPNV6_NODE
:
1446 case BGP_FLOWSPECV4_NODE
:
1447 case BGP_FLOWSPECV6_NODE
:
1448 case BGP_VRF_POLICY_NODE
:
1449 case BGP_VNC_DEFAULTS_NODE
:
1450 case BGP_VNC_NVE_GROUP_NODE
:
1451 case BGP_VNC_L2_GROUP_NODE
:
1453 case BGP_IPV6M_NODE
:
1455 case BGP_IPV6L_NODE
:
1456 vty
->node
= BGP_NODE
;
1458 case BGP_EVPN_VNI_NODE
:
1459 vty
->node
= BGP_EVPN_NODE
;
1463 vty
->node
= LDP_NODE
;
1465 case LDP_IPV4_IFACE_NODE
:
1466 vty
->node
= LDP_IPV4_NODE
;
1468 case LDP_IPV6_IFACE_NODE
:
1469 vty
->node
= LDP_IPV6_NODE
;
1471 case LDP_PSEUDOWIRE_NODE
:
1472 vty
->node
= LDP_L2VPN_NODE
;
1474 case KEYCHAIN_KEY_NODE
:
1475 vty
->node
= KEYCHAIN_NODE
;
1477 case LINK_PARAMS_NODE
:
1478 vty
->node
= INTERFACE_NODE
;
1489 "Exit current mode and down to previous mode\n")
1491 return config_exit(self
, vty
, argc
, argv
);
1495 /* End of configuration. */
1499 "End current mode and change to enable mode.\n")
1501 switch (vty
->node
) {
1504 /* Nothing to do. */
1507 case INTERFACE_NODE
:
1509 case LOGICALROUTER_NODE
:
1518 case BGP_VRF_POLICY_NODE
:
1519 case BGP_VNC_DEFAULTS_NODE
:
1520 case BGP_VNC_NVE_GROUP_NODE
:
1521 case BGP_VNC_L2_GROUP_NODE
:
1522 case BGP_VPNV4_NODE
:
1523 case BGP_VPNV6_NODE
:
1524 case BGP_FLOWSPECV4_NODE
:
1525 case BGP_FLOWSPECV6_NODE
:
1527 case BGP_IPV4M_NODE
:
1528 case BGP_IPV4L_NODE
:
1530 case BGP_IPV6M_NODE
:
1532 case BGP_EVPN_VNI_NODE
:
1533 case BGP_IPV6L_NODE
:
1541 case LDP_IPV4_IFACE_NODE
:
1542 case LDP_IPV6_IFACE_NODE
:
1543 case LDP_L2VPN_NODE
:
1544 case LDP_PSEUDOWIRE_NODE
:
1547 case KEYCHAIN_KEY_NODE
:
1549 case LINK_PARAMS_NODE
:
1550 vty_config_unlock(vty
);
1551 vty
->node
= ENABLE_NODE
;
1560 DEFUN (show_version
,
1564 "Displays zebra version\n")
1566 vty_out(vty
, "%s %s (%s).\n", FRR_FULL_NAME
, FRR_VERSION
,
1567 cmd_hostname_get() ? cmd_hostname_get() : "");
1568 vty_out(vty
, "%s%s\n", FRR_COPYRIGHT
, GIT_INFO
);
1569 vty_out(vty
, "configured with:\n %s\n", FRR_CONFIG_ARGS
);
1574 /* "Set" version ... ignore version tags */
1575 DEFUN (frr_version_defaults
,
1576 frr_version_defaults_cmd
,
1577 "frr <version|defaults> LINE...",
1578 "FRRouting global parameters\n"
1579 "version configuration was written by\n"
1580 "set of configuration defaults used\n"
1586 /* Help display function for all node. */
1590 "Description of the interactive help system\n")
1593 "Quagga VTY provides advanced help feature. When you need help,\n\
1594 anytime at the command line please press '?'.\n\
1596 If nothing matches, the help list will be empty and you must backup\n\
1597 until entering a '?' shows the available options.\n\
1598 Two styles of help are provided:\n\
1599 1. Full help is available when you are ready to enter a\n\
1600 command argument (e.g. 'show ?') and describes each possible\n\
1602 2. Partial help is provided when an abbreviated argument is entered\n\
1603 and you want to know what arguments match the input\n\
1604 (e.g. 'show me?'.)\n\n");
1608 static void permute(struct graph_node
*start
, struct vty
*vty
)
1610 static struct list
*position
= NULL
;
1612 position
= list_new();
1614 struct cmd_token
*stok
= start
->data
;
1615 struct graph_node
*gnn
;
1616 struct listnode
*ln
;
1619 listnode_add(position
, start
);
1620 for (unsigned int i
= 0; i
< vector_active(start
->to
); i
++) {
1621 struct graph_node
*gn
= vector_slot(start
->to
, i
);
1622 struct cmd_token
*tok
= gn
->data
;
1623 if (tok
->attr
== CMD_ATTR_HIDDEN
1624 || tok
->attr
== CMD_ATTR_DEPRECATED
)
1626 else if (tok
->type
== END_TKN
|| gn
== start
) {
1628 for (ALL_LIST_ELEMENTS_RO(position
, ln
, gnn
)) {
1629 struct cmd_token
*tt
= gnn
->data
;
1630 if (tt
->type
< SPECIAL_TKN
)
1631 vty_out(vty
, " %s", tt
->text
);
1634 vty_out(vty
, "...");
1638 if (stok
->type
== FORK_TKN
&& tok
->type
!= FORK_TKN
)
1639 for (ALL_LIST_ELEMENTS_RO(position
, ln
, gnn
))
1648 list_delete_node(position
, listtail(position
));
1651 int cmd_list_cmds(struct vty
*vty
, int do_permute
)
1653 struct cmd_node
*node
= vector_slot(cmdvec
, vty
->node
);
1656 permute(vector_slot(node
->cmdgraph
->nodes
, 0), vty
);
1658 /* loop over all commands at this node */
1659 struct cmd_element
*element
= NULL
;
1660 for (unsigned int i
= 0; i
< vector_active(node
->cmd_vector
);
1662 if ((element
= vector_slot(node
->cmd_vector
, i
))
1663 && element
->attr
!= CMD_ATTR_DEPRECATED
1664 && element
->attr
!= CMD_ATTR_HIDDEN
)
1665 vty_out(vty
, " %s\n", element
->string
);
1670 /* Help display function for all node. */
1673 "list [permutations]",
1674 "Print command list\n"
1675 "Print all possible command permutations\n")
1677 return cmd_list_cmds(vty
, argc
== 2);
1680 DEFUN (show_commandtree
,
1681 show_commandtree_cmd
,
1682 "show commandtree [permutations]",
1684 "Show command tree\n"
1685 "Permutations that we are interested in\n")
1687 return cmd_list_cmds(vty
, argc
== 3);
1690 DEFUN_HIDDEN(show_cli_graph
,
1695 "Dump current command space as DOT graph\n")
1697 struct cmd_node
*cn
= vector_slot(cmdvec
, vty
->node
);
1698 char *dot
= cmd_graph_dump_dot(cn
->cmdgraph
);
1700 vty_out(vty
, "%s\n", dot
);
1701 XFREE(MTYPE_TMP
, dot
);
1705 static int vty_write_config(struct vty
*vty
)
1708 struct cmd_node
*node
;
1713 if (vty
->type
== VTY_TERM
) {
1714 vty_out(vty
, "\nCurrent configuration:\n");
1715 vty_out(vty
, "!\n");
1718 vty_out(vty
, "frr version %s\n", FRR_VER_SHORT
);
1719 vty_out(vty
, "frr defaults %s\n", DFLT_NAME
);
1720 vty_out(vty
, "!\n");
1722 for (i
= 0; i
< vector_active(cmdvec
); i
++)
1723 if ((node
= vector_slot(cmdvec
, i
)) && node
->func
1724 && (node
->vtysh
|| vty
->type
!= VTY_SHELL
)) {
1725 if ((*node
->func
)(vty
))
1726 vty_out(vty
, "!\n");
1729 if (vty
->type
== VTY_TERM
) {
1730 vty_out(vty
, "end\n");
1736 static int file_write_config(struct vty
*vty
)
1739 char *config_file
, *slash
;
1740 char *config_file_tmp
= NULL
;
1741 char *config_file_sav
= NULL
;
1742 int ret
= CMD_WARNING
;
1743 struct vty
*file_vty
;
1744 struct stat conf_stat
;
1749 /* Check and see if we are operating under vtysh configuration */
1750 if (host
.config
== NULL
) {
1752 "Can't save to configuration file, using vtysh.\n");
1757 config_file
= host
.config
;
1760 #define O_DIRECTORY 0
1762 slash
= strrchr(config_file
, '/');
1764 char *config_dir
= XSTRDUP(MTYPE_TMP
, config_file
);
1765 config_dir
[slash
- config_file
] = '\0';
1766 dirfd
= open(config_dir
, O_DIRECTORY
| O_RDONLY
);
1767 XFREE(MTYPE_TMP
, config_dir
);
1769 dirfd
= open(".", O_DIRECTORY
| O_RDONLY
);
1770 /* if dirfd is invalid, directory sync fails, but we're still OK */
1772 config_file_sav
= XMALLOC(
1773 MTYPE_TMP
, strlen(config_file
) + strlen(CONF_BACKUP_EXT
) + 1);
1774 strcpy(config_file_sav
, config_file
);
1775 strcat(config_file_sav
, CONF_BACKUP_EXT
);
1778 config_file_tmp
= XMALLOC(MTYPE_TMP
, strlen(config_file
) + 8);
1779 sprintf(config_file_tmp
, "%s.XXXXXX", config_file
);
1781 /* Open file to configuration write. */
1782 fd
= mkstemp(config_file_tmp
);
1784 vty_out(vty
, "Can't open configuration file %s.\n",
1788 if (fchmod(fd
, CONFIGFILE_MASK
) != 0) {
1789 vty_out(vty
, "Can't chmod configuration file %s: %s (%d).\n",
1790 config_file_tmp
, safe_strerror(errno
), errno
);
1794 /* Make vty for configuration file. */
1795 file_vty
= vty_new();
1797 file_vty
->type
= VTY_FILE
;
1799 /* Config file header print. */
1800 vty_out(file_vty
, "!\n! Zebra configuration saved from vty\n! ");
1801 vty_time_print(file_vty
, 1);
1802 vty_out(file_vty
, "!\n");
1803 vty_write_config(file_vty
);
1804 vty_close(file_vty
);
1806 if (stat(config_file
, &conf_stat
) >= 0) {
1807 if (unlink(config_file_sav
) != 0)
1808 if (errno
!= ENOENT
) {
1810 "Can't unlink backup configuration file %s.\n",
1814 if (link(config_file
, config_file_sav
) != 0) {
1816 "Can't backup old configuration file %s.\n",
1823 if (rename(config_file_tmp
, config_file
) != 0) {
1824 vty_out(vty
, "Can't save configuration file %s.\n",
1831 vty_out(vty
, "Configuration saved to %s\n", config_file
);
1835 if (ret
!= CMD_SUCCESS
)
1836 unlink(config_file_tmp
);
1839 XFREE(MTYPE_TMP
, config_file_tmp
);
1840 XFREE(MTYPE_TMP
, config_file_sav
);
1844 /* Write current configuration into file. */
1846 DEFUN (config_write
,
1848 "write [<file|memory|terminal>]",
1849 "Write running configuration to memory, network, or terminal\n"
1850 "Write to configuration file\n"
1851 "Write configuration currently in memory\n"
1852 "Write configuration to terminal\n")
1854 const int idx_type
= 1;
1856 // if command was 'write terminal' or 'write memory'
1857 if (argc
== 2 && (!strcmp(argv
[idx_type
]->text
, "terminal"))) {
1858 return vty_write_config(vty
);
1861 return file_write_config(vty
);
1864 /* ALIAS_FIXME for 'write <terminal|memory>' */
1865 DEFUN (show_running_config
,
1866 show_running_config_cmd
,
1867 "show running-config",
1869 "running configuration (same as write terminal)\n")
1871 return vty_write_config(vty
);
1874 /* ALIAS_FIXME for 'write file' */
1875 DEFUN (copy_runningconf_startupconf
,
1876 copy_runningconf_startupconf_cmd
,
1877 "copy running-config startup-config",
1878 "Copy configuration\n"
1879 "Copy running config to... \n"
1880 "Copy running config to startup config (same as write file/memory)\n")
1882 return file_write_config(vty
);
1886 /* Write startup configuration into the terminal. */
1887 DEFUN (show_startup_config
,
1888 show_startup_config_cmd
,
1889 "show startup-config",
1891 "Contents of startup configuration\n")
1898 if (host
.config
== NULL
)
1901 confp
= fopen(host
.config
, "r");
1902 if (confp
== NULL
) {
1903 vty_out(vty
, "Can't open configuration file [%s] due to '%s'\n",
1904 host
.config
, safe_strerror(errno
));
1908 while (fgets(buf
, BUFSIZ
, confp
)) {
1911 while (*cp
!= '\r' && *cp
!= '\n' && *cp
!= '\0')
1915 vty_out(vty
, "%s\n", buf
);
1923 int cmd_domainname_set(const char *domainname
)
1925 XFREE(MTYPE_HOST
, host
.domainname
);
1926 host
.domainname
= domainname
? XSTRDUP(MTYPE_HOST
, domainname
) : NULL
;
1930 /* Hostname configuration */
1931 DEFUN(config_domainname
,
1934 "Set system's domain name\n"
1935 "This system's domain name\n")
1937 struct cmd_token
*word
= argv
[1];
1939 if (!isalpha((int)word
->arg
[0])) {
1940 vty_out(vty
, "Please specify string starting with alphabet\n");
1941 return CMD_WARNING_CONFIG_FAILED
;
1944 return cmd_domainname_set(word
->arg
);
1947 DEFUN(config_no_domainname
,
1949 "no domainname [DOMAINNAME]",
1951 "Reset system's domain name\n"
1952 "domain name of this router\n")
1954 return cmd_domainname_set(NULL
);
1957 int cmd_hostname_set(const char *hostname
)
1959 XFREE(MTYPE_HOST
, host
.name
);
1960 host
.name
= hostname
? XSTRDUP(MTYPE_HOST
, hostname
) : NULL
;
1964 /* Hostname configuration */
1965 DEFUN (config_hostname
,
1968 "Set system's network name\n"
1969 "This system's network name\n")
1971 struct cmd_token
*word
= argv
[1];
1973 if (!isalnum((int)word
->arg
[0])) {
1974 vty_out(vty
, "Please specify string starting with alphabet\n");
1975 return CMD_WARNING_CONFIG_FAILED
;
1978 return cmd_hostname_set(word
->arg
);
1981 DEFUN (config_no_hostname
,
1983 "no hostname [HOSTNAME]",
1985 "Reset system's network name\n"
1986 "Host name of this router\n")
1988 return cmd_hostname_set(NULL
);
1991 /* VTY interface password set. */
1992 DEFUN (config_password
,
1994 "password [(8-8)] WORD",
1995 "Modify the terminal connection password\n"
1996 "Specifies a HIDDEN password will follow\n"
1997 "The password string\n")
2001 if (argc
== 3) // '8' was specified
2004 XFREE(MTYPE_HOST
, host
.password
);
2005 host
.password
= NULL
;
2006 if (host
.password_encrypt
)
2007 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2008 host
.password_encrypt
=
2009 XSTRDUP(MTYPE_HOST
, argv
[idx_word
]->arg
);
2013 if (!isalnum((int)argv
[idx_8
]->arg
[0])) {
2015 "Please specify string starting with alphanumeric\n");
2016 return CMD_WARNING_CONFIG_FAILED
;
2020 XFREE(MTYPE_HOST
, host
.password
);
2021 host
.password
= NULL
;
2024 if (host
.password_encrypt
)
2025 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2026 host
.password_encrypt
=
2027 XSTRDUP(MTYPE_HOST
, zencrypt(argv
[idx_8
]->arg
));
2029 host
.password
= XSTRDUP(MTYPE_HOST
, argv
[idx_8
]->arg
);
2034 /* VTY interface password delete. */
2035 DEFUN (no_config_password
,
2039 "Modify the terminal connection password\n")
2041 bool warned
= false;
2043 if (host
.password
) {
2044 if (!vty_shell_serv(vty
)) {
2045 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
2048 XFREE(MTYPE_HOST
, host
.password
);
2050 host
.password
= NULL
;
2052 if (host
.password_encrypt
) {
2053 if (!warned
&& !vty_shell_serv(vty
))
2054 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
2055 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2057 host
.password_encrypt
= NULL
;
2062 /* VTY enable password set. */
2063 DEFUN (config_enable_password
,
2064 enable_password_cmd
,
2065 "enable password [(8-8)] WORD",
2066 "Modify enable password parameters\n"
2067 "Assign the privileged level password\n"
2068 "Specifies a HIDDEN password will follow\n"
2069 "The HIDDEN 'enable' password string\n")
2074 /* Crypt type is specified. */
2076 if (argv
[idx_8
]->arg
[0] == '8') {
2078 XFREE(MTYPE_HOST
, host
.enable
);
2081 if (host
.enable_encrypt
)
2082 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2083 host
.enable_encrypt
=
2084 XSTRDUP(MTYPE_HOST
, argv
[idx_word
]->arg
);
2088 vty_out(vty
, "Unknown encryption type.\n");
2089 return CMD_WARNING_CONFIG_FAILED
;
2093 if (!isalnum((int)argv
[idx_8
]->arg
[0])) {
2095 "Please specify string starting with alphanumeric\n");
2096 return CMD_WARNING_CONFIG_FAILED
;
2100 XFREE(MTYPE_HOST
, host
.enable
);
2103 /* Plain password input. */
2105 if (host
.enable_encrypt
)
2106 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2107 host
.enable_encrypt
=
2108 XSTRDUP(MTYPE_HOST
, zencrypt(argv
[idx_8
]->arg
));
2110 host
.enable
= XSTRDUP(MTYPE_HOST
, argv
[idx_8
]->arg
);
2115 /* VTY enable password delete. */
2116 DEFUN (no_config_enable_password
,
2117 no_enable_password_cmd
,
2118 "no enable password",
2120 "Modify enable password parameters\n"
2121 "Assign the privileged level password\n")
2123 bool warned
= false;
2126 if (!vty_shell_serv(vty
)) {
2127 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
2130 XFREE(MTYPE_HOST
, host
.enable
);
2134 if (host
.enable_encrypt
) {
2135 if (!warned
&& !vty_shell_serv(vty
))
2136 vty_out(vty
, NO_PASSWD_CMD_WARNING
);
2137 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2139 host
.enable_encrypt
= NULL
;
2144 DEFUN (service_password_encrypt
,
2145 service_password_encrypt_cmd
,
2146 "service password-encryption",
2147 "Set up miscellaneous service\n"
2148 "Enable encrypted passwords\n")
2155 if (host
.password
) {
2156 if (host
.password_encrypt
)
2157 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2158 host
.password_encrypt
=
2159 XSTRDUP(MTYPE_HOST
, zencrypt(host
.password
));
2162 if (host
.enable_encrypt
)
2163 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2164 host
.enable_encrypt
=
2165 XSTRDUP(MTYPE_HOST
, zencrypt(host
.enable
));
2171 DEFUN (no_service_password_encrypt
,
2172 no_service_password_encrypt_cmd
,
2173 "no service password-encryption",
2175 "Set up miscellaneous service\n"
2176 "Enable encrypted passwords\n")
2183 if (host
.password_encrypt
)
2184 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2185 host
.password_encrypt
= NULL
;
2187 if (host
.enable_encrypt
)
2188 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2189 host
.enable_encrypt
= NULL
;
2194 DEFUN (config_terminal_length
,
2195 config_terminal_length_cmd
,
2196 "terminal length (0-512)",
2197 "Set terminal line parameters\n"
2198 "Set number of lines on a screen\n"
2199 "Number of lines on screen (0 for no pausing)\n")
2203 vty
->lines
= atoi(argv
[idx_number
]->arg
);
2208 DEFUN (config_terminal_no_length
,
2209 config_terminal_no_length_cmd
,
2210 "terminal no length",
2211 "Set terminal line parameters\n"
2213 "Set number of lines on a screen\n")
2219 DEFUN (service_terminal_length
,
2220 service_terminal_length_cmd
,
2221 "service terminal-length (0-512)",
2222 "Set up miscellaneous service\n"
2223 "System wide terminal length configuration\n"
2224 "Number of lines of VTY (0 means no line control)\n")
2228 host
.lines
= atoi(argv
[idx_number
]->arg
);
2233 DEFUN (no_service_terminal_length
,
2234 no_service_terminal_length_cmd
,
2235 "no service terminal-length [(0-512)]",
2237 "Set up miscellaneous service\n"
2238 "System wide terminal length configuration\n"
2239 "Number of lines of VTY (0 means no line control)\n")
2245 DEFUN_HIDDEN (do_echo
,
2248 "Echo a message back to the vty\n"
2249 "The message to echo\n")
2253 vty_out(vty
, "%s\n",
2254 ((message
= argv_concat(argv
, argc
, 1)) ? message
: ""));
2256 XFREE(MTYPE_TMP
, message
);
2260 DEFUN (config_logmsg
,
2262 "logmsg <emergencies|alerts|critical|errors|warnings|notifications|informational|debugging> MESSAGE...",
2263 "Send a message to enabled logging destinations\n"
2265 "The message to send\n")
2267 int idx_log_level
= 1;
2268 int idx_message
= 2;
2272 if ((level
= level_match(argv
[idx_log_level
]->arg
)) == ZLOG_DISABLED
)
2273 return CMD_ERR_NO_MATCH
;
2276 ((message
= argv_concat(argv
, argc
, idx_message
)) ? message
: ""));
2278 XFREE(MTYPE_TMP
, message
);
2283 DEFUN (show_logging
,
2287 "Show current logging configuration\n")
2289 struct zlog
*zl
= zlog_default
;
2291 vty_out(vty
, "Syslog logging: ");
2292 if (zl
->maxlvl
[ZLOG_DEST_SYSLOG
] == ZLOG_DISABLED
)
2293 vty_out(vty
, "disabled");
2295 vty_out(vty
, "level %s, facility %s, ident %s",
2296 zlog_priority
[zl
->maxlvl
[ZLOG_DEST_SYSLOG
]],
2297 facility_name(zl
->facility
), zl
->ident
);
2300 vty_out(vty
, "Stdout logging: ");
2301 if (zl
->maxlvl
[ZLOG_DEST_STDOUT
] == ZLOG_DISABLED
)
2302 vty_out(vty
, "disabled");
2304 vty_out(vty
, "level %s",
2305 zlog_priority
[zl
->maxlvl
[ZLOG_DEST_STDOUT
]]);
2308 vty_out(vty
, "Monitor logging: ");
2309 if (zl
->maxlvl
[ZLOG_DEST_MONITOR
] == ZLOG_DISABLED
)
2310 vty_out(vty
, "disabled");
2312 vty_out(vty
, "level %s",
2313 zlog_priority
[zl
->maxlvl
[ZLOG_DEST_MONITOR
]]);
2316 vty_out(vty
, "File logging: ");
2317 if ((zl
->maxlvl
[ZLOG_DEST_FILE
] == ZLOG_DISABLED
) || !zl
->fp
)
2318 vty_out(vty
, "disabled");
2320 vty_out(vty
, "level %s, filename %s",
2321 zlog_priority
[zl
->maxlvl
[ZLOG_DEST_FILE
]],
2325 vty_out(vty
, "Protocol name: %s\n", zl
->protoname
);
2326 vty_out(vty
, "Record priority: %s\n",
2327 (zl
->record_priority
? "enabled" : "disabled"));
2328 vty_out(vty
, "Timestamp precision: %d\n", zl
->timestamp_precision
);
2333 DEFUN (config_log_stdout
,
2334 config_log_stdout_cmd
,
2335 "log stdout [<emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>]",
2337 "Set stdout logging level\n"
2340 int idx_log_level
= 2;
2342 if (argc
== idx_log_level
) {
2343 zlog_set_level(ZLOG_DEST_STDOUT
, zlog_default
->default_lvl
);
2348 if ((level
= level_match(argv
[idx_log_level
]->arg
)) == ZLOG_DISABLED
)
2349 return CMD_ERR_NO_MATCH
;
2350 zlog_set_level(ZLOG_DEST_STDOUT
, level
);
2354 DEFUN (no_config_log_stdout
,
2355 no_config_log_stdout_cmd
,
2356 "no log stdout [<emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>]",
2359 "Cancel logging to stdout\n"
2362 zlog_set_level(ZLOG_DEST_STDOUT
, ZLOG_DISABLED
);
2366 DEFUN (config_log_monitor
,
2367 config_log_monitor_cmd
,
2368 "log monitor [<emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>]",
2370 "Set terminal line (monitor) logging level\n"
2373 int idx_log_level
= 2;
2375 if (argc
== idx_log_level
) {
2376 zlog_set_level(ZLOG_DEST_MONITOR
, zlog_default
->default_lvl
);
2381 if ((level
= level_match(argv
[idx_log_level
]->arg
)) == ZLOG_DISABLED
)
2382 return CMD_ERR_NO_MATCH
;
2383 zlog_set_level(ZLOG_DEST_MONITOR
, level
);
2387 DEFUN (no_config_log_monitor
,
2388 no_config_log_monitor_cmd
,
2389 "no log monitor [<emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>]",
2392 "Disable terminal line (monitor) logging\n"
2395 zlog_set_level(ZLOG_DEST_MONITOR
, ZLOG_DISABLED
);
2399 static int set_log_file(struct vty
*vty
, const char *fname
, int loglevel
)
2403 const char *fullpath
;
2405 /* Path detection. */
2406 if (!IS_DIRECTORY_SEP(*fname
)) {
2407 char cwd
[MAXPATHLEN
+ 1];
2408 cwd
[MAXPATHLEN
] = '\0';
2410 if (getcwd(cwd
, MAXPATHLEN
) == NULL
) {
2411 zlog_err("config_log_file: Unable to alloc mem!");
2412 return CMD_WARNING_CONFIG_FAILED
;
2415 if ((p
= XMALLOC(MTYPE_TMP
, strlen(cwd
) + strlen(fname
) + 2))
2417 zlog_err("config_log_file: Unable to alloc mem!");
2418 return CMD_WARNING_CONFIG_FAILED
;
2420 sprintf(p
, "%s/%s", cwd
, fname
);
2425 ret
= zlog_set_file(fullpath
, loglevel
);
2428 XFREE(MTYPE_TMP
, p
);
2431 vty_out(vty
, "can't open logfile %s\n", fname
);
2432 return CMD_WARNING_CONFIG_FAILED
;
2436 XFREE(MTYPE_HOST
, host
.logfile
);
2438 host
.logfile
= XSTRDUP(MTYPE_HOST
, fname
);
2440 #if defined(HAVE_CUMULUS)
2441 if (zlog_default
->maxlvl
[ZLOG_DEST_SYSLOG
] != ZLOG_DISABLED
)
2442 zlog_set_level(ZLOG_DEST_SYSLOG
, ZLOG_DISABLED
);
2447 DEFUN (config_log_file
,
2448 config_log_file_cmd
,
2449 "log file FILENAME [<emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>]",
2452 "Logging filename\n"
2455 int idx_filename
= 2;
2456 int idx_log_levels
= 3;
2459 if ((level
= level_match(argv
[idx_log_levels
]->arg
))
2461 return CMD_ERR_NO_MATCH
;
2462 return set_log_file(vty
, argv
[idx_filename
]->arg
, level
);
2464 return set_log_file(vty
, argv
[idx_filename
]->arg
,
2465 zlog_default
->default_lvl
);
2468 static void disable_log_file(void)
2473 XFREE(MTYPE_HOST
, host
.logfile
);
2475 host
.logfile
= NULL
;
2478 DEFUN (no_config_log_file
,
2479 no_config_log_file_cmd
,
2480 "no log file [FILENAME [LEVEL]]",
2483 "Cancel logging to file\n"
2484 "Logging file name\n"
2491 DEFUN (config_log_syslog
,
2492 config_log_syslog_cmd
,
2493 "log syslog [<emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>]",
2495 "Set syslog logging level\n"
2498 int idx_log_levels
= 2;
2504 if ((level
= level_match(argv
[idx_log_levels
]->arg
))
2506 return CMD_ERR_NO_MATCH
;
2507 zlog_set_level(ZLOG_DEST_SYSLOG
, level
);
2510 zlog_set_level(ZLOG_DEST_SYSLOG
, zlog_default
->default_lvl
);
2515 DEFUN (no_config_log_syslog
,
2516 no_config_log_syslog_cmd
,
2517 "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>]",
2520 "Cancel logging to syslog\n"
2524 zlog_set_level(ZLOG_DEST_SYSLOG
, ZLOG_DISABLED
);
2528 DEFUN (config_log_facility
,
2529 config_log_facility_cmd
,
2530 "log facility <kern|user|mail|daemon|auth|syslog|lpr|news|uucp|cron|local0|local1|local2|local3|local4|local5|local6|local7>",
2532 "Facility parameter for syslog messages\n"
2536 int facility
= facility_match(argv
[idx_target
]->arg
);
2538 zlog_default
->facility
= facility
;
2542 DEFUN (no_config_log_facility
,
2543 no_config_log_facility_cmd
,
2544 "no log facility [<kern|user|mail|daemon|auth|syslog|lpr|news|uucp|cron|local0|local1|local2|local3|local4|local5|local6|local7>]",
2547 "Reset syslog facility to default (daemon)\n"
2550 zlog_default
->facility
= LOG_DAEMON
;
2555 config_log_trap
, config_log_trap_cmd
,
2556 "log trap <emergencies|alerts|critical|errors|warnings|notifications|informational|debugging>",
2558 "(Deprecated) Set logging level and default for all destinations\n" LOG_LEVEL_DESC
)
2563 if ((new_level
= level_match(argv
[2]->arg
)) == ZLOG_DISABLED
)
2564 return CMD_ERR_NO_MATCH
;
2566 zlog_default
->default_lvl
= new_level
;
2567 for (i
= 0; i
< ZLOG_NUM_DESTS
; i
++)
2568 if (zlog_default
->maxlvl
[i
] != ZLOG_DISABLED
)
2569 zlog_default
->maxlvl
[i
] = new_level
;
2574 no_config_log_trap
, no_config_log_trap_cmd
,
2575 "no log trap [emergencies|alerts|critical|errors|warnings|notifications|informational|debugging]",
2578 "Permit all logging information\n" LOG_LEVEL_DESC
)
2580 zlog_default
->default_lvl
= LOG_DEBUG
;
2584 DEFUN (config_log_record_priority
,
2585 config_log_record_priority_cmd
,
2586 "log record-priority",
2588 "Log the priority of the message within the message\n")
2590 zlog_default
->record_priority
= 1;
2594 DEFUN (no_config_log_record_priority
,
2595 no_config_log_record_priority_cmd
,
2596 "no log record-priority",
2599 "Do not log the priority of the message within the message\n")
2601 zlog_default
->record_priority
= 0;
2605 DEFUN (config_log_timestamp_precision
,
2606 config_log_timestamp_precision_cmd
,
2607 "log timestamp precision (0-6)",
2609 "Timestamp configuration\n"
2610 "Set the timestamp precision\n"
2611 "Number of subsecond digits\n")
2614 zlog_default
->timestamp_precision
=
2615 strtoul(argv
[idx_number
]->arg
, NULL
, 10);
2619 DEFUN (no_config_log_timestamp_precision
,
2620 no_config_log_timestamp_precision_cmd
,
2621 "no log timestamp precision",
2624 "Timestamp configuration\n"
2625 "Reset the timestamp precision to the default value of 0\n")
2627 zlog_default
->timestamp_precision
= 0;
2631 DEFUN (debug_memstats
,
2633 "[no] debug memstats-at-exit",
2636 "Print memory type statistics at exit\n")
2638 debug_memstats_at_exit
= !!strcmp(argv
[0]->text
, "no");
2642 int cmd_banner_motd_file(const char *file
)
2644 int success
= CMD_SUCCESS
;
2649 rpath
= realpath(file
, p
);
2651 return CMD_ERR_NO_FILE
;
2652 in
= strstr(rpath
, SYSCONFDIR
);
2655 XFREE(MTYPE_HOST
, host
.motdfile
);
2656 host
.motdfile
= XSTRDUP(MTYPE_HOST
, file
);
2658 success
= CMD_WARNING_CONFIG_FAILED
;
2663 DEFUN (banner_motd_file
,
2664 banner_motd_file_cmd
,
2665 "banner motd file FILE",
2668 "Banner from a file\n"
2672 const char *filename
= argv
[idx_file
]->arg
;
2673 int cmd
= cmd_banner_motd_file(filename
);
2675 if (cmd
== CMD_ERR_NO_FILE
)
2676 vty_out(vty
, "%s does not exist", filename
);
2677 else if (cmd
== CMD_WARNING_CONFIG_FAILED
)
2678 vty_out(vty
, "%s must be in %s", filename
, SYSCONFDIR
);
2683 DEFUN (banner_motd_default
,
2684 banner_motd_default_cmd
,
2685 "banner motd default",
2686 "Set banner string\n"
2687 "Strings for motd\n"
2690 host
.motd
= default_motd
;
2694 DEFUN (no_banner_motd
,
2698 "Set banner string\n"
2699 "Strings for motd\n")
2703 XFREE(MTYPE_HOST
, host
.motdfile
);
2704 host
.motdfile
= NULL
;
2711 "Find CLI command containing text\n"
2712 "Text to search for\n")
2714 char *text
= argv_concat(argv
, argc
, 1);
2715 const struct cmd_node
*node
;
2716 const struct cmd_element
*cli
;
2719 for (unsigned int i
= 0; i
< vector_active(cmdvec
); i
++) {
2720 node
= vector_slot(cmdvec
, i
);
2723 clis
= node
->cmd_vector
;
2724 for (unsigned int j
= 0; j
< vector_active(clis
); j
++) {
2725 cli
= vector_slot(clis
, j
);
2726 if (strcasestr(cli
->string
, text
))
2727 vty_out(vty
, " (%s) %s\n",
2728 node_names
[node
->node
], cli
->string
);
2732 XFREE(MTYPE_TMP
, text
);
2737 /* Set config filename. Called from vty.c */
2738 void host_config_set(const char *filename
)
2741 XFREE(MTYPE_HOST
, host
.config
);
2742 host
.config
= XSTRDUP(MTYPE_HOST
, filename
);
2745 const char *host_config_get(void)
2750 void install_default(enum node_type node
)
2752 install_element(node
, &config_exit_cmd
);
2753 install_element(node
, &config_quit_cmd
);
2754 install_element(node
, &config_end_cmd
);
2755 install_element(node
, &config_help_cmd
);
2756 install_element(node
, &config_list_cmd
);
2757 install_element(node
, &show_cli_graph_cmd
);
2758 install_element(node
, &find_cmd
);
2760 install_element(node
, &config_write_cmd
);
2761 install_element(node
, &show_running_config_cmd
);
2763 install_element(node
, &autocomplete_cmd
);
2766 /* Initialize command interface. Install basic nodes and commands.
2768 * terminal = 0 -- vtysh / no logging, no config control
2769 * terminal = 1 -- normal daemon
2770 * terminal = -1 -- watchfrr / no logging, but minimal config control */
2771 void cmd_init(int terminal
)
2773 struct utsname names
;
2775 if (array_size(node_names
) != NODE_TYPE_MAX
)
2776 assert(!"Update the CLI node description array!");
2781 /* register command preprocessors */
2782 hook_register(cmd_execute
, handle_pipe_action
);
2783 hook_register(cmd_execute_done
, handle_pipe_action_done
);
2785 varhandlers
= list_new();
2787 /* Allocate initial top vector of commands. */
2788 cmdvec
= vector_init(VECTOR_MIN_SIZE
);
2790 /* Default host value settings. */
2791 host
.name
= XSTRDUP(MTYPE_HOST
, names
.nodename
);
2792 #ifdef HAVE_STRUCT_UTSNAME_DOMAINNAME
2793 if ((strcmp(names
.domainname
, "(none)") == 0))
2794 host
.domainname
= NULL
;
2796 host
.domainname
= XSTRDUP(MTYPE_HOST
, names
.domainname
);
2798 host
.domainname
= NULL
;
2800 host
.password
= NULL
;
2802 host
.logfile
= NULL
;
2804 host
.noconfig
= (terminal
< 0);
2806 host
.motd
= default_motd
;
2807 host
.motdfile
= NULL
;
2809 /* Install top nodes. */
2810 install_node(&view_node
, NULL
);
2811 install_node(&enable_node
, NULL
);
2812 install_node(&auth_node
, NULL
);
2813 install_node(&auth_enable_node
, NULL
);
2814 install_node(&config_node
, config_write_host
);
2816 /* Each node's basic commands. */
2817 install_element(VIEW_NODE
, &show_version_cmd
);
2818 install_element(ENABLE_NODE
, &show_startup_config_cmd
);
2819 install_element(ENABLE_NODE
, &debug_memstats_cmd
);
2822 install_element(VIEW_NODE
, &config_list_cmd
);
2823 install_element(VIEW_NODE
, &config_exit_cmd
);
2824 install_element(VIEW_NODE
, &config_quit_cmd
);
2825 install_element(VIEW_NODE
, &config_help_cmd
);
2826 install_element(VIEW_NODE
, &config_enable_cmd
);
2827 install_element(VIEW_NODE
, &config_terminal_length_cmd
);
2828 install_element(VIEW_NODE
, &config_terminal_no_length_cmd
);
2829 install_element(VIEW_NODE
, &show_logging_cmd
);
2830 install_element(VIEW_NODE
, &show_commandtree_cmd
);
2831 install_element(VIEW_NODE
, &echo_cmd
);
2832 install_element(VIEW_NODE
, &autocomplete_cmd
);
2833 install_element(VIEW_NODE
, &find_cmd
);
2835 install_element(ENABLE_NODE
, &config_end_cmd
);
2836 install_element(ENABLE_NODE
, &config_disable_cmd
);
2837 install_element(ENABLE_NODE
, &config_terminal_cmd
);
2838 install_element(ENABLE_NODE
, ©_runningconf_startupconf_cmd
);
2839 install_element(ENABLE_NODE
, &config_write_cmd
);
2840 install_element(ENABLE_NODE
, &show_running_config_cmd
);
2841 install_element(ENABLE_NODE
, &config_logmsg_cmd
);
2843 install_default(CONFIG_NODE
);
2846 workqueue_cmd_init();
2850 install_element(CONFIG_NODE
, &hostname_cmd
);
2851 install_element(CONFIG_NODE
, &no_hostname_cmd
);
2852 install_element(CONFIG_NODE
, &domainname_cmd
);
2853 install_element(CONFIG_NODE
, &no_domainname_cmd
);
2854 install_element(CONFIG_NODE
, &frr_version_defaults_cmd
);
2855 install_element(CONFIG_NODE
, &debug_memstats_cmd
);
2858 install_element(CONFIG_NODE
, &password_cmd
);
2859 install_element(CONFIG_NODE
, &no_password_cmd
);
2860 install_element(CONFIG_NODE
, &enable_password_cmd
);
2861 install_element(CONFIG_NODE
, &no_enable_password_cmd
);
2863 install_element(CONFIG_NODE
, &config_log_stdout_cmd
);
2864 install_element(CONFIG_NODE
, &no_config_log_stdout_cmd
);
2865 install_element(CONFIG_NODE
, &config_log_monitor_cmd
);
2866 install_element(CONFIG_NODE
, &no_config_log_monitor_cmd
);
2867 install_element(CONFIG_NODE
, &config_log_file_cmd
);
2868 install_element(CONFIG_NODE
, &no_config_log_file_cmd
);
2869 install_element(CONFIG_NODE
, &config_log_syslog_cmd
);
2870 install_element(CONFIG_NODE
, &no_config_log_syslog_cmd
);
2871 install_element(CONFIG_NODE
, &config_log_facility_cmd
);
2872 install_element(CONFIG_NODE
, &no_config_log_facility_cmd
);
2873 install_element(CONFIG_NODE
, &config_log_trap_cmd
);
2874 install_element(CONFIG_NODE
, &no_config_log_trap_cmd
);
2875 install_element(CONFIG_NODE
, &config_log_record_priority_cmd
);
2876 install_element(CONFIG_NODE
,
2877 &no_config_log_record_priority_cmd
);
2878 install_element(CONFIG_NODE
,
2879 &config_log_timestamp_precision_cmd
);
2880 install_element(CONFIG_NODE
,
2881 &no_config_log_timestamp_precision_cmd
);
2882 install_element(CONFIG_NODE
, &service_password_encrypt_cmd
);
2883 install_element(CONFIG_NODE
, &no_service_password_encrypt_cmd
);
2884 install_element(CONFIG_NODE
, &banner_motd_default_cmd
);
2885 install_element(CONFIG_NODE
, &banner_motd_file_cmd
);
2886 install_element(CONFIG_NODE
, &no_banner_motd_cmd
);
2887 install_element(CONFIG_NODE
, &service_terminal_length_cmd
);
2888 install_element(CONFIG_NODE
, &no_service_terminal_length_cmd
);
2890 vrf_install_commands();
2894 grammar_sandbox_init();
2898 void cmd_terminate()
2900 struct cmd_node
*cmd_node
;
2902 hook_unregister(cmd_execute
, handle_pipe_action
);
2903 hook_unregister(cmd_execute_done
, handle_pipe_action_done
);
2906 for (unsigned int i
= 0; i
< vector_active(cmdvec
); i
++)
2907 if ((cmd_node
= vector_slot(cmdvec
, i
)) != NULL
) {
2908 // deleting the graph delets the cmd_element as
2910 graph_delete_graph(cmd_node
->cmdgraph
);
2911 vector_free(cmd_node
->cmd_vector
);
2912 hash_clean(cmd_node
->cmd_hash
, NULL
);
2913 hash_free(cmd_node
->cmd_hash
);
2914 cmd_node
->cmd_hash
= NULL
;
2917 vector_free(cmdvec
);
2922 XFREE(MTYPE_HOST
, host
.name
);
2923 if (host
.domainname
)
2924 XFREE(MTYPE_HOST
, host
.domainname
);
2926 XFREE(MTYPE_HOST
, host
.password
);
2927 if (host
.password_encrypt
)
2928 XFREE(MTYPE_HOST
, host
.password_encrypt
);
2930 XFREE(MTYPE_HOST
, host
.enable
);
2931 if (host
.enable_encrypt
)
2932 XFREE(MTYPE_HOST
, host
.enable_encrypt
);
2934 XFREE(MTYPE_HOST
, host
.logfile
);
2936 XFREE(MTYPE_HOST
, host
.motdfile
);
2938 XFREE(MTYPE_HOST
, host
.config
);
2940 list_delete_and_null(&varhandlers
);