summaryrefslogtreecommitdiffstats
path: root/lib/command.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib/command.c')
-rw-r--r--lib/command.c2633
1 files changed, 2633 insertions, 0 deletions
diff --git a/lib/command.c b/lib/command.c
new file mode 100644
index 0000000..ca05cd6
--- /dev/null
+++ b/lib/command.c
@@ -0,0 +1,2633 @@
+/*
+ * CLI backend interface.
+ *
+ * --
+ * Copyright (C) 2016 Cumulus Networks, Inc.
+ * Copyright (C) 1997, 98, 99 Kunihiro Ishiguro
+ * Copyright (C) 2013 by Open Source Routing.
+ * Copyright (C) 2013 by Internet Systems Consortium, Inc. ("ISC")
+ *
+ * This file is part of GNU Zebra.
+ *
+ * GNU Zebra is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * GNU Zebra is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <zebra.h>
+#include <lib/version.h>
+
+#include "command.h"
+#include "frrstr.h"
+#include "memory.h"
+#include "log.h"
+#include "log_vty.h"
+#include "thread.h"
+#include "vector.h"
+#include "linklist.h"
+#include "vty.h"
+#include "workqueue.h"
+#include "vrf.h"
+#include "command_match.h"
+#include "command_graph.h"
+#include "qobj.h"
+#include "defaults.h"
+#include "libfrr.h"
+#include "jhash.h"
+#include "hook.h"
+#include "lib_errors.h"
+#include "northbound_cli.h"
+#include "network.h"
+
+#include "frrscript.h"
+
+DEFINE_MTYPE_STATIC(LIB, HOST, "Host config");
+DEFINE_MTYPE(LIB, COMPLETION, "Completion item");
+
+#define item(x) \
+ { \
+ x, #x \
+ }
+
+/* clang-format off */
+const struct message tokennames[] = {
+ item(WORD_TKN),
+ item(VARIABLE_TKN),
+ item(RANGE_TKN),
+ item(IPV4_TKN),
+ item(IPV4_PREFIX_TKN),
+ item(IPV6_TKN),
+ item(IPV6_PREFIX_TKN),
+ item(MAC_TKN),
+ item(MAC_PREFIX_TKN),
+ item(FORK_TKN),
+ item(JOIN_TKN),
+ item(START_TKN),
+ item(END_TKN),
+ item(NEG_ONLY_TKN),
+ {0},
+};
+/* clang-format on */
+
+/* Command vector which includes some level of command lists. Normally
+ each daemon maintains each own cmdvec. */
+vector cmdvec = NULL;
+
+/* Host information structure. */
+struct host host;
+
+/* for vtysh, put together CLI trees only when switching into node */
+static bool defer_cli_tree;
+
+/*
+ * Returns host.name if any, otherwise
+ * it returns the system hostname.
+ */
+const char *cmd_hostname_get(void)
+{
+ return host.name;
+}
+
+/*
+ * Returns unix domainname
+ */
+const char *cmd_domainname_get(void)
+{
+ return host.domainname;
+}
+
+const char *cmd_system_get(void)
+{
+ return host.system;
+}
+
+const char *cmd_release_get(void)
+{
+ return host.release;
+}
+
+const char *cmd_version_get(void)
+{
+ return host.version;
+}
+
+bool cmd_allow_reserved_ranges_get(void)
+{
+ return host.allow_reserved_ranges;
+}
+
+static int root_on_exit(struct vty *vty);
+
+/* Standard command node structures. */
+static struct cmd_node auth_node = {
+ .name = "auth",
+ .node = AUTH_NODE,
+ .prompt = "Password: ",
+};
+
+static struct cmd_node view_node = {
+ .name = "view",
+ .node = VIEW_NODE,
+ .prompt = "%s> ",
+ .node_exit = root_on_exit,
+};
+
+static struct cmd_node auth_enable_node = {
+ .name = "auth enable",
+ .node = AUTH_ENABLE_NODE,
+ .prompt = "Password: ",
+};
+
+static struct cmd_node enable_node = {
+ .name = "enable",
+ .node = ENABLE_NODE,
+ .prompt = "%s# ",
+ .node_exit = root_on_exit,
+};
+
+static int config_write_host(struct vty *vty);
+static struct cmd_node config_node = {
+ .name = "config",
+ .node = CONFIG_NODE,
+ .parent_node = ENABLE_NODE,
+ .prompt = "%s(config)# ",
+ .config_write = config_write_host,
+ .node_exit = vty_config_node_exit,
+};
+
+/* This is called from main when a daemon is invoked with -v or --version. */
+void print_version(const char *progname)
+{
+ printf("%s version %s\n", progname, FRR_VERSION);
+ printf("%s\n", FRR_COPYRIGHT);
+#ifdef ENABLE_VERSION_BUILD_CONFIG
+ printf("configured with:\n\t%s\n", FRR_CONFIG_ARGS);
+#endif
+}
+
+char *argv_concat(struct cmd_token **argv, int argc, int shift)
+{
+ int cnt = MAX(argc - shift, 0);
+ const char *argstr[cnt + 1];
+
+ if (!cnt)
+ return NULL;
+
+ for (int i = 0; i < cnt; i++)
+ argstr[i] = argv[i + shift]->arg;
+
+ return frrstr_join(argstr, cnt, " ");
+}
+
+vector cmd_make_strvec(const char *string)
+{
+ if (!string)
+ return NULL;
+
+ const char *copy = string;
+
+ /* skip leading whitespace */
+ while (isspace((unsigned char)*copy) && *copy != '\0')
+ copy++;
+
+ /* if the entire string was whitespace or a comment, return */
+ if (*copy == '\0' || *copy == '!' || *copy == '#')
+ return NULL;
+
+ vector result = frrstr_split_vec(copy, "\n\r\t ");
+
+ for (unsigned int i = 0; i < vector_active(result); i++) {
+ if (strlen(vector_slot(result, i)) == 0) {
+ XFREE(MTYPE_TMP, vector_slot(result, i));
+ vector_unset(result, i);
+ }
+ }
+
+ vector_compact(result);
+
+ return result;
+}
+
+void cmd_free_strvec(vector v)
+{
+ frrstr_strvec_free(v);
+}
+
+/**
+ * Convenience function for accessing argv data.
+ *
+ * @param argc
+ * @param argv
+ * @param text definition snippet of the desired token
+ * @param index the starting index, and where to store the
+ * index of the found token if it exists
+ * @return 1 if found, 0 otherwise
+ */
+int argv_find(struct cmd_token **argv, int argc, const char *text, int *index)
+{
+ int found = 0;
+ for (int i = *index; i < argc && found == 0; i++)
+ if ((found = strmatch(text, argv[i]->text)))
+ *index = i;
+ return found;
+}
+
+static unsigned int cmd_hash_key(const void *p)
+{
+ int size = sizeof(p);
+
+ return jhash(p, size, 0);
+}
+
+static bool cmd_hash_cmp(const void *a, const void *b)
+{
+ return a == b;
+}
+
+/* Install top node of command vector. */
+void install_node(struct cmd_node *node)
+{
+#define CMD_HASH_STR_SIZE 256
+ char hash_name[CMD_HASH_STR_SIZE];
+
+ vector_set_index(cmdvec, node->node, node);
+ node->cmdgraph = graph_new();
+ node->cmd_vector = vector_init(VECTOR_MIN_SIZE);
+ // add start node
+ struct cmd_token *token =
+ cmd_token_new(START_TKN, CMD_ATTR_NORMAL, NULL, NULL);
+ graph_new_node(node->cmdgraph, token,
+ (void (*)(void *)) & cmd_token_del);
+
+ snprintf(hash_name, sizeof(hash_name), "Command Hash: %s", node->name);
+ node->cmd_hash =
+ hash_create_size(16, cmd_hash_key, cmd_hash_cmp, hash_name);
+}
+
+/* Return prompt character of specified node. */
+const char *cmd_prompt(enum node_type node)
+{
+ struct cmd_node *cnode;
+
+ cnode = vector_slot(cmdvec, node);
+ return cnode->prompt;
+}
+
+void cmd_defer_tree(bool val)
+{
+ defer_cli_tree = val;
+}
+
+/* Install a command into a node. */
+void _install_element(enum node_type ntype, const struct cmd_element *cmd)
+{
+ struct cmd_node *cnode;
+
+ /* cmd_init hasn't been called */
+ if (!cmdvec) {
+ fprintf(stderr, "%s called before cmd_init, breakage likely\n",
+ __func__);
+ return;
+ }
+
+ cnode = vector_lookup(cmdvec, ntype);
+
+ if (cnode == NULL) {
+ fprintf(stderr,
+ "%s[%s]:\n"
+ "\tnode %d does not exist.\n"
+ "\tplease call install_node() before install_element()\n",
+ cmd->name, cmd->string, ntype);
+ exit(EXIT_FAILURE);
+ }
+
+ if (hash_lookup(cnode->cmd_hash, (void *)cmd) != NULL) {
+ fprintf(stderr,
+ "%s[%s]:\n"
+ "\tnode %d (%s) already has this command installed.\n"
+ "\tduplicate install_element call?\n",
+ cmd->name, cmd->string, ntype, cnode->name);
+ return;
+ }
+
+ (void)hash_get(cnode->cmd_hash, (void *)cmd, hash_alloc_intern);
+
+ if (cnode->graph_built || !defer_cli_tree) {
+ struct graph *graph = graph_new();
+ struct cmd_token *token =
+ cmd_token_new(START_TKN, CMD_ATTR_NORMAL, NULL, NULL);
+ graph_new_node(graph, token,
+ (void (*)(void *)) & cmd_token_del);
+
+ cmd_graph_parse(graph, cmd);
+ cmd_graph_names(graph);
+ cmd_graph_merge(cnode->cmdgraph, graph, +1);
+ graph_delete_graph(graph);
+
+ cnode->graph_built = true;
+ }
+
+ vector_set(cnode->cmd_vector, (void *)cmd);
+
+ if (ntype == VIEW_NODE)
+ _install_element(ENABLE_NODE, cmd);
+}
+
+static void cmd_finalize_iter(struct hash_bucket *hb, void *arg)
+{
+ struct cmd_node *cnode = arg;
+ const struct cmd_element *cmd = hb->data;
+ struct graph *graph = graph_new();
+ struct cmd_token *token =
+ cmd_token_new(START_TKN, CMD_ATTR_NORMAL, NULL, NULL);
+
+ graph_new_node(graph, token, (void (*)(void *)) & cmd_token_del);
+
+ cmd_graph_parse(graph, cmd);
+ cmd_graph_names(graph);
+ cmd_graph_merge(cnode->cmdgraph, graph, +1);
+ graph_delete_graph(graph);
+}
+
+void cmd_finalize_node(struct cmd_node *cnode)
+{
+ if (cnode->graph_built)
+ return;
+
+ hash_iterate(cnode->cmd_hash, cmd_finalize_iter, cnode);
+ cnode->graph_built = true;
+}
+
+void uninstall_element(enum node_type ntype, const struct cmd_element *cmd)
+{
+ struct cmd_node *cnode;
+
+ /* cmd_init hasn't been called */
+ if (!cmdvec) {
+ fprintf(stderr, "%s called before cmd_init, breakage likely\n",
+ __func__);
+ return;
+ }
+
+ cnode = vector_lookup(cmdvec, ntype);
+
+ if (cnode == NULL) {
+ fprintf(stderr,
+ "%s[%s]:\n"
+ "\tnode %d does not exist.\n"
+ "\tplease call install_node() before uninstall_element()\n",
+ cmd->name, cmd->string, ntype);
+ exit(EXIT_FAILURE);
+ }
+
+ if (hash_release(cnode->cmd_hash, (void *)cmd) == NULL) {
+ fprintf(stderr,
+ "%s[%s]:\n"
+ "\tnode %d (%s) does not have this command installed.\n"
+ "\tduplicate uninstall_element call?\n",
+ cmd->name, cmd->string, ntype, cnode->name);
+ return;
+ }
+
+ vector_unset_value(cnode->cmd_vector, (void *)cmd);
+
+ if (cnode->graph_built) {
+ struct graph *graph = graph_new();
+ struct cmd_token *token =
+ cmd_token_new(START_TKN, CMD_ATTR_NORMAL, NULL, NULL);
+ graph_new_node(graph, token,
+ (void (*)(void *)) & cmd_token_del);
+
+ cmd_graph_parse(graph, cmd);
+ cmd_graph_names(graph);
+ cmd_graph_merge(cnode->cmdgraph, graph, -1);
+ graph_delete_graph(graph);
+ }
+
+ if (ntype == VIEW_NODE)
+ uninstall_element(ENABLE_NODE, cmd);
+}
+
+
+static const unsigned char itoa64[] =
+ "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+static void to64(char *s, long v, int n)
+{
+ while (--n >= 0) {
+ *s++ = itoa64[v & 0x3f];
+ v >>= 6;
+ }
+}
+
+static char *zencrypt(const char *passwd)
+{
+ char salt[6];
+ struct timeval tv;
+
+ gettimeofday(&tv, 0);
+
+ to64(&salt[0], frr_weak_random(), 3);
+ to64(&salt[3], tv.tv_usec, 3);
+ salt[5] = '\0';
+
+ return crypt(passwd, salt);
+}
+
+static bool full_cli;
+
+/* This function write configuration of this host. */
+static int config_write_host(struct vty *vty)
+{
+ const char *name;
+
+ name = cmd_hostname_get();
+ if (name && name[0] != '\0')
+ vty_out(vty, "hostname %s\n", name);
+
+ name = cmd_domainname_get();
+ if (name && name[0] != '\0')
+ vty_out(vty, "domainname %s\n", name);
+
+ if (cmd_allow_reserved_ranges_get())
+ vty_out(vty, "allow-reserved-ranges\n");
+
+ /* The following are all configuration commands that are not sent to
+ * watchfrr. For instance watchfrr is hardcoded to log to syslog so
+ * we would always display 'log syslog informational' in the config
+ * which would cause other daemons to then switch to syslog when they
+ * parse frr.conf.
+ */
+ if (full_cli) {
+ if (host.encrypt) {
+ if (host.password_encrypt)
+ vty_out(vty, "password 8 %s\n",
+ host.password_encrypt);
+ if (host.enable_encrypt)
+ vty_out(vty, "enable password 8 %s\n",
+ host.enable_encrypt);
+ } else {
+ if (host.password)
+ vty_out(vty, "password %s\n", host.password);
+ if (host.enable)
+ vty_out(vty, "enable password %s\n",
+ host.enable);
+ }
+ log_config_write(vty);
+
+ /* print disable always, but enable only if default is flipped
+ * => prep for future removal of compile-time knob
+ */
+ if (!cputime_enabled)
+ vty_out(vty, "no service cputime-stats\n");
+#ifdef EXCLUDE_CPU_TIME
+ else
+ vty_out(vty, "service cputime-stats\n");
+#endif
+
+ if (!cputime_threshold)
+ vty_out(vty, "no service cputime-warning\n");
+#if defined(CONSUMED_TIME_CHECK) && CONSUMED_TIME_CHECK != 5000000
+ else /* again, always print non-default */
+#else
+ else if (cputime_threshold != 5000000)
+#endif
+ vty_out(vty, "service cputime-warning %lu\n",
+ cputime_threshold);
+
+ if (!walltime_threshold)
+ vty_out(vty, "no service walltime-warning\n");
+#if defined(CONSUMED_TIME_CHECK) && CONSUMED_TIME_CHECK != 5000000
+ else /* again, always print non-default */
+#else
+ else if (walltime_threshold != 5000000)
+#endif
+ vty_out(vty, "service walltime-warning %lu\n",
+ walltime_threshold);
+
+ if (host.advanced)
+ vty_out(vty, "service advanced-vty\n");
+
+ if (host.encrypt)
+ vty_out(vty, "service password-encryption\n");
+
+ if (host.lines >= 0)
+ vty_out(vty, "service terminal-length %d\n",
+ host.lines);
+
+ if (host.motdfile)
+ vty_out(vty, "banner motd file %s\n", host.motdfile);
+ else if (host.motd
+ && strncmp(host.motd, FRR_DEFAULT_MOTD,
+ strlen(host.motd)))
+ vty_out(vty, "banner motd line %s\n", host.motd);
+ else if (!host.motd)
+ vty_out(vty, "no banner motd\n");
+ }
+
+ if (debug_memstats_at_exit)
+ vty_out(vty, "!\ndebug memstats-at-exit\n");
+
+ return 1;
+}
+
+/* Utility function for getting command graph. */
+static struct graph *cmd_node_graph(vector v, enum node_type ntype)
+{
+ struct cmd_node *cnode = vector_slot(v, ntype);
+
+ cmd_finalize_node(cnode);
+ return cnode->cmdgraph;
+}
+
+static int cmd_try_do_shortcut(enum node_type node, char *first_word)
+{
+ if (first_word != NULL && node != AUTH_NODE && node != VIEW_NODE
+ && node != AUTH_ENABLE_NODE && 0 == strcmp("do", first_word))
+ return 1;
+ return 0;
+}
+
+/**
+ * Compare function for cmd_token.
+ * Used with qsort to sort command completions.
+ */
+static int compare_completions(const void *fst, const void *snd)
+{
+ const struct cmd_token *first = *(const struct cmd_token * const *)fst,
+ *secnd = *(const struct cmd_token * const *)snd;
+ return strcmp(first->text, secnd->text);
+}
+
+/**
+ * Takes a list of completions returned by command_complete,
+ * dedeuplicates them based on both text and description,
+ * sorts them, and returns them as a vector.
+ *
+ * @param completions linked list of cmd_token
+ * @return deduplicated and sorted vector with
+ */
+vector completions_to_vec(struct list *completions)
+{
+ vector comps = vector_init(VECTOR_MIN_SIZE);
+
+ struct listnode *ln;
+ struct cmd_token *token, *cr = NULL;
+ unsigned int i, exists;
+ for (ALL_LIST_ELEMENTS_RO(completions, ln, token)) {
+ if (token->type == END_TKN && (cr = token))
+ continue;
+
+ // linear search for token in completions vector
+ exists = 0;
+ for (i = 0; i < vector_active(comps) && !exists; i++) {
+ struct cmd_token *curr = vector_slot(comps, i);
+#ifdef VTYSH_DEBUG
+ exists = !strcmp(curr->text, token->text)
+ && !strcmp(curr->desc, token->desc);
+#else
+ exists = !strcmp(curr->text, token->text);
+#endif /* VTYSH_DEBUG */
+ }
+
+ if (!exists)
+ vector_set(comps, token);
+ }
+
+ // sort completions
+ qsort(comps->index, vector_active(comps), sizeof(void *),
+ &compare_completions);
+
+ // make <cr> the first element, if it is present
+ if (cr) {
+ vector_set_index(comps, vector_active(comps), NULL);
+ memmove(comps->index + 1, comps->index,
+ (comps->alloced - 1) * sizeof(void *));
+ vector_set_index(comps, 0, cr);
+ }
+
+ return comps;
+}
+/**
+ * Generates a vector of cmd_token representing possible completions
+ * on the current input.
+ *
+ * @param vline the vectorized input line
+ * @param vty the vty with the node to match on
+ * @param status pointer to matcher status code
+ * @return vector of struct cmd_token * with possible completions
+ */
+static vector cmd_complete_command_real(vector vline, struct vty *vty,
+ int *status)
+{
+ struct list *completions;
+ struct graph *cmdgraph = cmd_node_graph(cmdvec, vty->node);
+
+ enum matcher_rv rv = command_complete(cmdgraph, vline, &completions);
+
+ if (MATCHER_ERROR(rv)) {
+ *status = CMD_ERR_NO_MATCH;
+ return NULL;
+ }
+
+ vector comps = completions_to_vec(completions);
+ list_delete(&completions);
+
+ // set status code appropriately
+ switch (vector_active(comps)) {
+ case 0:
+ *status = CMD_ERR_NO_MATCH;
+ break;
+ case 1:
+ *status = CMD_COMPLETE_FULL_MATCH;
+ break;
+ default:
+ *status = CMD_COMPLETE_LIST_MATCH;
+ }
+
+ return comps;
+}
+
+vector cmd_describe_command(vector vline, struct vty *vty, int *status)
+{
+ vector ret;
+
+ if (cmd_try_do_shortcut(vty->node, vector_slot(vline, 0))) {
+ enum node_type onode;
+ int orig_xpath_index;
+ vector shifted_vline;
+ unsigned int index;
+
+ onode = vty->node;
+ orig_xpath_index = vty->xpath_index;
+ vty->node = ENABLE_NODE;
+ vty->xpath_index = 0;
+ /* We can try it on enable node, cos' the vty is authenticated
+ */
+
+ shifted_vline = vector_init(vector_count(vline));
+ /* use memcpy? */
+ for (index = 1; index < vector_active(vline); index++) {
+ vector_set_index(shifted_vline, index - 1,
+ vector_lookup(vline, index));
+ }
+
+ ret = cmd_complete_command_real(shifted_vline, vty, status);
+
+ vector_free(shifted_vline);
+ vty->node = onode;
+ vty->xpath_index = orig_xpath_index;
+ return ret;
+ }
+
+ return cmd_complete_command_real(vline, vty, status);
+}
+
+static struct list *varhandlers = NULL;
+
+void cmd_variable_complete(struct cmd_token *token, const char *arg,
+ vector comps)
+{
+ struct listnode *ln;
+ const struct cmd_variable_handler *cvh;
+ size_t i, argsz;
+ vector tmpcomps;
+
+ tmpcomps = arg ? vector_init(VECTOR_MIN_SIZE) : comps;
+
+ for (ALL_LIST_ELEMENTS_RO(varhandlers, ln, cvh)) {
+ if (cvh->tokenname && strcmp(cvh->tokenname, token->text))
+ continue;
+ if (cvh->varname && (!token->varname
+ || strcmp(cvh->varname, token->varname)))
+ continue;
+ cvh->completions(tmpcomps, token);
+ break;
+ }
+
+ if (!arg)
+ return;
+
+ argsz = strlen(arg);
+ for (i = vector_active(tmpcomps); i; i--) {
+ char *item = vector_slot(tmpcomps, i - 1);
+ if (strlen(item) >= argsz && !strncmp(item, arg, argsz))
+ vector_set(comps, item);
+ else
+ XFREE(MTYPE_COMPLETION, item);
+ }
+ vector_free(tmpcomps);
+}
+
+#define AUTOCOMP_INDENT 5
+
+char *cmd_variable_comp2str(vector comps, unsigned short cols)
+{
+ size_t bsz = 16;
+ char *buf = XCALLOC(MTYPE_TMP, bsz);
+ int lc = AUTOCOMP_INDENT;
+ size_t cs = AUTOCOMP_INDENT;
+ size_t itemlen;
+ snprintf(buf, bsz, "%*s", AUTOCOMP_INDENT, "");
+ for (size_t j = 0; j < vector_active(comps); j++) {
+ char *item = vector_slot(comps, j);
+ itemlen = strlen(item);
+
+ size_t next_sz = cs + itemlen + AUTOCOMP_INDENT + 3;
+
+ if (next_sz > bsz) {
+ /* Make sure the buf size is large enough */
+ bsz = next_sz;
+ buf = XREALLOC(MTYPE_TMP, buf, bsz);
+ }
+ if (lc + itemlen + 1 >= cols) {
+ cs += snprintf(&buf[cs], bsz - cs, "\n%*s",
+ AUTOCOMP_INDENT, "");
+ lc = AUTOCOMP_INDENT;
+ }
+
+ size_t written = snprintf(&buf[cs], bsz - cs, "%s ", item);
+ lc += written;
+ cs += written;
+ XFREE(MTYPE_COMPLETION, item);
+ vector_set_index(comps, j, NULL);
+ }
+ return buf;
+}
+
+void cmd_variable_handler_register(const struct cmd_variable_handler *cvh)
+{
+ if (!varhandlers)
+ return;
+
+ for (; cvh->completions; cvh++)
+ listnode_add(varhandlers, (void *)cvh);
+}
+
+DEFUN_HIDDEN (autocomplete,
+ autocomplete_cmd,
+ "autocomplete TYPE TEXT VARNAME",
+ "Autocompletion handler (internal, for vtysh)\n"
+ "cmd_token->type\n"
+ "cmd_token->text\n"
+ "cmd_token->varname\n")
+{
+ struct cmd_token tok;
+ vector comps = vector_init(32);
+ size_t i;
+
+ memset(&tok, 0, sizeof(tok));
+ tok.type = atoi(argv[1]->arg);
+ tok.text = argv[2]->arg;
+ tok.varname = argv[3]->arg;
+ if (!strcmp(tok.varname, "-"))
+ tok.varname = NULL;
+
+ cmd_variable_complete(&tok, NULL, comps);
+
+ for (i = 0; i < vector_active(comps); i++) {
+ char *text = vector_slot(comps, i);
+ vty_out(vty, "%s\n", text);
+ XFREE(MTYPE_COMPLETION, text);
+ }
+
+ vector_free(comps);
+ return CMD_SUCCESS;
+}
+
+/**
+ * Generate possible tab-completions for the given input. This function only
+ * returns results that would result in a valid command if used as Readline
+ * completions (as is the case in vtysh). For instance, if the passed vline ends
+ * with '4.3.2', the strings 'A.B.C.D' and 'A.B.C.D/M' will _not_ be returned.
+ *
+ * @param vline vectorized input line
+ * @param vty the vty
+ * @param status location to store matcher status code in
+ * @return set of valid strings for use with Readline as tab-completions.
+ */
+
+char **cmd_complete_command(vector vline, struct vty *vty, int *status)
+{
+ char **ret = NULL;
+ int original_node = vty->node;
+ vector input_line = vector_init(vector_count(vline));
+
+ // if the first token is 'do' we'll want to execute the command in the
+ // enable node
+ int do_shortcut = cmd_try_do_shortcut(vty->node, vector_slot(vline, 0));
+ vty->node = do_shortcut ? ENABLE_NODE : original_node;
+
+ // construct the input line we'll be matching on
+ unsigned int offset = (do_shortcut) ? 1 : 0;
+ for (unsigned index = 0; index + offset < vector_active(vline); index++)
+ vector_set_index(input_line, index,
+ vector_lookup(vline, index + offset));
+
+ // get token completions -- this is a copying operation
+ vector comps = NULL, initial_comps;
+ initial_comps = cmd_complete_command_real(input_line, vty, status);
+
+ if (!MATCHER_ERROR(*status)) {
+ assert(initial_comps);
+ // filter out everything that is not suitable for a
+ // tab-completion
+ comps = vector_init(VECTOR_MIN_SIZE);
+ for (unsigned int i = 0; i < vector_active(initial_comps);
+ i++) {
+ struct cmd_token *token = vector_slot(initial_comps, i);
+ if (token->type == WORD_TKN)
+ vector_set(comps, XSTRDUP(MTYPE_COMPLETION,
+ token->text));
+ else if (IS_VARYING_TOKEN(token->type)) {
+ const char *ref = vector_lookup(
+ vline, vector_active(vline) - 1);
+ cmd_variable_complete(token, ref, comps);
+ }
+ }
+ vector_free(initial_comps);
+
+ // since we filtered results, we need to re-set status code
+ switch (vector_active(comps)) {
+ case 0:
+ *status = CMD_ERR_NO_MATCH;
+ break;
+ case 1:
+ *status = CMD_COMPLETE_FULL_MATCH;
+ break;
+ default:
+ *status = CMD_COMPLETE_LIST_MATCH;
+ }
+
+ // copy completions text into an array of char*
+ ret = XMALLOC(MTYPE_TMP,
+ (vector_active(comps) + 1) * sizeof(char *));
+ unsigned int i;
+ for (i = 0; i < vector_active(comps); i++) {
+ ret[i] = vector_slot(comps, i);
+ }
+ // set the last element to NULL, because this array is used in
+ // a Readline completion_generator function which expects NULL
+ // as a sentinel value
+ ret[i] = NULL;
+ vector_free(comps);
+ comps = NULL;
+ } else if (initial_comps)
+ vector_free(initial_comps);
+
+ // comps should always be null here
+ assert(!comps);
+
+ // free the adjusted input line
+ vector_free(input_line);
+
+ // reset vty->node to its original value
+ vty->node = original_node;
+
+ return ret;
+}
+
+/* return parent node */
+/* MUST eventually converge on CONFIG_NODE */
+enum node_type node_parent(enum node_type node)
+{
+ struct cmd_node *cnode;
+
+ assert(node > CONFIG_NODE);
+
+ cnode = vector_lookup(cmdvec, node);
+
+ return cnode->parent_node;
+}
+
+/* Execute command by argument vline vector. */
+static int cmd_execute_command_real(vector vline, enum cmd_filter_type filter,
+ struct vty *vty,
+ const struct cmd_element **cmd,
+ unsigned int up_level)
+{
+ struct list *argv_list;
+ enum matcher_rv status;
+ const struct cmd_element *matched_element = NULL;
+ unsigned int i;
+ int xpath_index = vty->xpath_index;
+ int node = vty->node;
+
+ /* only happens for legacy split config file load; need to check for
+ * a match before calling node_exit handlers below
+ */
+ for (i = 0; i < up_level; i++) {
+ struct cmd_node *cnode;
+
+ if (node <= CONFIG_NODE)
+ return CMD_NO_LEVEL_UP;
+
+ cnode = vector_slot(cmdvec, node);
+ node = node_parent(node);
+
+ if (xpath_index > 0 && !cnode->no_xpath)
+ xpath_index--;
+ }
+
+ struct graph *cmdgraph = cmd_node_graph(cmdvec, node);
+ status = command_match(cmdgraph, vline, &argv_list, &matched_element);
+
+ if (cmd)
+ *cmd = matched_element;
+
+ // if matcher error, return corresponding CMD_ERR
+ if (MATCHER_ERROR(status)) {
+ if (argv_list)
+ list_delete(&argv_list);
+ switch (status) {
+ case MATCHER_INCOMPLETE:
+ return CMD_ERR_INCOMPLETE;
+ case MATCHER_AMBIGUOUS:
+ return CMD_ERR_AMBIGUOUS;
+ default:
+ return CMD_ERR_NO_MATCH;
+ }
+ }
+
+ for (i = 0; i < up_level; i++)
+ cmd_exit(vty);
+
+ // build argv array from argv list
+ struct cmd_token **argv = XMALLOC(
+ MTYPE_TMP, argv_list->count * sizeof(struct cmd_token *));
+ struct listnode *ln;
+ struct cmd_token *token;
+
+ i = 0;
+ for (ALL_LIST_ELEMENTS_RO(argv_list, ln, token))
+ argv[i++] = token;
+
+ int argc = argv_list->count;
+
+ int ret;
+ if (matched_element->daemon)
+ ret = CMD_SUCCESS_DAEMON;
+ else {
+ if (vty->config) {
+ /* Clear array of enqueued configuration changes. */
+ vty->num_cfg_changes = 0;
+ memset(&vty->cfg_changes, 0, sizeof(vty->cfg_changes));
+
+ /* Regenerate candidate configuration if necessary. */
+ if (frr_get_cli_mode() == FRR_CLI_CLASSIC
+ && running_config->version
+ > vty->candidate_config->version)
+ nb_config_replace(vty->candidate_config,
+ running_config, true);
+
+ /*
+ * Perform pending commit (if any) before executing
+ * non-YANG command.
+ */
+ if (matched_element->attr != CMD_ATTR_YANG)
+ (void)nb_cli_pending_commit_check(vty);
+ }
+
+ ret = matched_element->func(matched_element, vty, argc, argv);
+ }
+
+ // delete list and cmd_token's in it
+ list_delete(&argv_list);
+ XFREE(MTYPE_TMP, argv);
+
+ return ret;
+}
+
+/**
+ * Execute a given command, handling things like "do ..." and checking
+ * whether the given command might apply at a parent node if doesn't
+ * apply for the current node.
+ *
+ * @param vline Command line input, vector of char* where each element is
+ * one input token.
+ * @param vty The vty context in which the command should be executed.
+ * @param cmd Pointer where the struct cmd_element of the matched command
+ * will be stored, if any. May be set to NULL if this info is
+ * not needed.
+ * @param vtysh If set != 0, don't lookup the command at parent nodes.
+ * @return The status of the command that has been executed or an error code
+ * as to why no command could be executed.
+ */
+int cmd_execute_command(vector vline, struct vty *vty,
+ const struct cmd_element **cmd, int vtysh)
+{
+ int ret, saved_ret = 0;
+ enum node_type onode, try_node;
+ int orig_xpath_index;
+
+ onode = try_node = vty->node;
+ orig_xpath_index = vty->xpath_index;
+
+ if (cmd_try_do_shortcut(vty->node, vector_slot(vline, 0))) {
+ vector shifted_vline;
+ unsigned int index;
+
+ vty->node = ENABLE_NODE;
+ vty->xpath_index = 0;
+ /* We can try it on enable node, cos' the vty is authenticated
+ */
+
+ shifted_vline = vector_init(vector_count(vline));
+ /* use memcpy? */
+ for (index = 1; index < vector_active(vline); index++)
+ vector_set_index(shifted_vline, index - 1,
+ vector_lookup(vline, index));
+
+ ret = cmd_execute_command_real(shifted_vline, FILTER_RELAXED,
+ vty, cmd, 0);
+
+ vector_free(shifted_vline);
+ vty->node = onode;
+ vty->xpath_index = orig_xpath_index;
+ return ret;
+ }
+
+ saved_ret = ret =
+ cmd_execute_command_real(vline, FILTER_RELAXED, vty, cmd, 0);
+
+ if (vtysh)
+ return saved_ret;
+
+ if (ret != CMD_SUCCESS && ret != CMD_WARNING
+ && ret != CMD_ERR_AMBIGUOUS && ret != CMD_ERR_INCOMPLETE
+ && ret != CMD_NOT_MY_INSTANCE && ret != CMD_WARNING_CONFIG_FAILED) {
+ /* This assumes all nodes above CONFIG_NODE are childs of
+ * CONFIG_NODE */
+ while (vty->node > CONFIG_NODE) {
+ struct cmd_node *cnode = vector_slot(cmdvec, try_node);
+
+ try_node = node_parent(try_node);
+ vty->node = try_node;
+ if (vty->xpath_index > 0 && !cnode->no_xpath)
+ vty->xpath_index--;
+
+ ret = cmd_execute_command_real(vline, FILTER_RELAXED,
+ vty, cmd, 0);
+ if (ret == CMD_SUCCESS || ret == CMD_WARNING
+ || ret == CMD_ERR_AMBIGUOUS || ret == CMD_ERR_INCOMPLETE
+ || ret == CMD_NOT_MY_INSTANCE
+ || ret == CMD_WARNING_CONFIG_FAILED)
+ return ret;
+ }
+ /* no command succeeded, reset the vty to the original node */
+ vty->node = onode;
+ vty->xpath_index = orig_xpath_index;
+ }
+
+ /* return command status for original node */
+ return saved_ret;
+}
+
+/**
+ * Execute a given command, matching it strictly against the current node.
+ * This mode is used when reading config files.
+ *
+ * @param vline Command line input, vector of char* where each element is
+ * one input token.
+ * @param vty The vty context in which the command should be executed.
+ * @param cmd Pointer where the struct cmd_element* of the matched command
+ * will be stored, if any. May be set to NULL if this info is
+ * not needed.
+ * @return The status of the command that has been executed or an error code
+ * as to why no command could be executed.
+ */
+int cmd_execute_command_strict(vector vline, struct vty *vty,
+ const struct cmd_element **cmd)
+{
+ return cmd_execute_command_real(vline, FILTER_STRICT, vty, cmd, 0);
+}
+
+/*
+ * Hook for preprocessing command string before executing.
+ *
+ * All subscribers are called with the raw command string that is to be
+ * executed. If any changes are to be made, a new string should be allocated
+ * with MTYPE_TMP and *cmd_out updated to point to this new string. The caller
+ * is then responsible for freeing this string.
+ *
+ * All processing functions must be mutually exclusive in their action, i.e. if
+ * one subscriber decides to modify the command, all others must not modify it
+ * when called. Feeding the output of one processing command into a subsequent
+ * one is not supported.
+ *
+ * This hook is intentionally internal to the command processing system.
+ *
+ * cmd_in
+ * The raw command string.
+ *
+ * cmd_out
+ * The result of any processing.
+ */
+DECLARE_HOOK(cmd_execute,
+ (struct vty *vty, const char *cmd_in, char **cmd_out),
+ (vty, cmd_in, cmd_out));
+DEFINE_HOOK(cmd_execute, (struct vty *vty, const char *cmd_in, char **cmd_out),
+ (vty, cmd_in, cmd_out));
+
+/* Hook executed after a CLI command. */
+DECLARE_KOOH(cmd_execute_done, (struct vty *vty, const char *cmd_exec),
+ (vty, cmd_exec));
+DEFINE_KOOH(cmd_execute_done, (struct vty *vty, const char *cmd_exec),
+ (vty, cmd_exec));
+
+/*
+ * cmd_execute hook subscriber to handle `|` actions.
+ */
+static int handle_pipe_action(struct vty *vty, const char *cmd_in,
+ char **cmd_out)
+{
+ /* look for `|` */
+ char *orig, *working, *token, *u;
+ char *pipe = strstr(cmd_in, "| ");
+ int ret = 0;
+
+ if (!pipe)
+ return 0;
+
+ /* duplicate string for processing purposes, not including pipe */
+ orig = working = XSTRDUP(MTYPE_TMP, pipe + 2);
+
+ /* retrieve action */
+ token = strsep(&working, " ");
+ assert(token);
+
+ /* match result to known actions */
+ if (strmatch(token, "include")) {
+ /* the remaining text should be a regexp */
+ char *regexp = working;
+
+ if (!regexp) {
+ vty_out(vty, "%% Need a regexp to filter with\n");
+ ret = 1;
+ goto fail;
+ }
+
+ bool succ = vty_set_include(vty, regexp);
+
+ if (!succ) {
+ vty_out(vty, "%% Bad regexp '%s'\n", regexp);
+ ret = 1;
+ goto fail;
+ }
+ *cmd_out = XSTRDUP(MTYPE_TMP, cmd_in);
+ u = *cmd_out;
+ strsep(&u, "|");
+ } else {
+ vty_out(vty, "%% Unknown action '%s'\n", token);
+ ret = 1;
+ goto fail;
+ }
+
+fail:
+ XFREE(MTYPE_TMP, orig);
+ return ret;
+}
+
+static int handle_pipe_action_done(struct vty *vty, const char *cmd_exec)
+{
+ if (vty->filter)
+ vty_set_include(vty, NULL);
+
+ return 0;
+}
+
+int cmd_execute(struct vty *vty, const char *cmd,
+ const struct cmd_element **matched, int vtysh)
+{
+ int ret;
+ char *cmd_out = NULL;
+ const char *cmd_exec = NULL;
+ vector vline;
+
+ ret = hook_call(cmd_execute, vty, cmd, &cmd_out);
+ if (ret) {
+ ret = CMD_WARNING;
+ goto free;
+ }
+
+ cmd_exec = cmd_out ? (const char *)cmd_out : cmd;
+
+ vline = cmd_make_strvec(cmd_exec);
+
+ if (vline) {
+ ret = cmd_execute_command(vline, vty, matched, vtysh);
+ cmd_free_strvec(vline);
+ } else {
+ ret = CMD_SUCCESS;
+ }
+
+free:
+ hook_call(cmd_execute_done, vty, cmd_exec);
+
+ XFREE(MTYPE_TMP, cmd_out);
+
+ return ret;
+}
+
+
+/**
+ * Parse one line of config, walking up the parse tree attempting to find a
+ * match
+ *
+ * @param vty The vty context in which the command should be executed.
+ * @param cmd Pointer where the struct cmd_element* of the match command
+ * will be stored, if any. May be set to NULL if this info is
+ * not needed.
+ * @param use_daemon Boolean to control whether or not we match on
+ * CMD_SUCCESS_DAEMON
+ * or not.
+ * @return The status of the command that has been executed or an error code
+ * as to why no command could be executed.
+ */
+int command_config_read_one_line(struct vty *vty,
+ const struct cmd_element **cmd,
+ uint32_t line_num, int use_daemon)
+{
+ vector vline;
+ int ret;
+ unsigned up_level = 0;
+
+ vline = cmd_make_strvec(vty->buf);
+
+ /* In case of comment line */
+ if (vline == NULL)
+ return CMD_SUCCESS;
+
+ /* Execute configuration command : this is strict match */
+ ret = cmd_execute_command_strict(vline, vty, cmd);
+
+ /* The logic for trying parent nodes is in cmd_execute_command_real()
+ * since calling ->node_exit() correctly is a bit involved. This is
+ * also the only reason CMD_NO_LEVEL_UP exists.
+ */
+ while (!(use_daemon && ret == CMD_SUCCESS_DAEMON)
+ && !(!use_daemon && ret == CMD_ERR_NOTHING_TODO)
+ && ret != CMD_SUCCESS && ret != CMD_WARNING
+ && ret != CMD_ERR_AMBIGUOUS && ret != CMD_ERR_INCOMPLETE
+ && ret != CMD_NOT_MY_INSTANCE && ret != CMD_WARNING_CONFIG_FAILED
+ && ret != CMD_NO_LEVEL_UP)
+ ret = cmd_execute_command_real(vline, FILTER_STRICT, vty, cmd,
+ ++up_level);
+
+ if (ret == CMD_NO_LEVEL_UP)
+ ret = CMD_ERR_NO_MATCH;
+
+ if (ret != CMD_SUCCESS &&
+ ret != CMD_WARNING &&
+ ret != CMD_SUCCESS_DAEMON) {
+ struct vty_error *ve = XCALLOC(MTYPE_TMP, sizeof(*ve));
+
+ memcpy(ve->error_buf, vty->buf, VTY_BUFSIZ);
+ ve->line_num = line_num;
+ if (!vty->error)
+ vty->error = list_new();
+
+ listnode_add(vty->error, ve);
+ }
+
+ cmd_free_strvec(vline);
+
+ return ret;
+}
+
+/* Configuration make from file. */
+int config_from_file(struct vty *vty, FILE *fp, unsigned int *line_num)
+{
+ int ret, error_ret = 0;
+ *line_num = 0;
+
+ while (fgets(vty->buf, VTY_BUFSIZ, fp)) {
+ ++(*line_num);
+
+ ret = command_config_read_one_line(vty, NULL, *line_num, 0);
+
+ if (ret != CMD_SUCCESS && ret != CMD_WARNING
+ && ret != CMD_ERR_NOTHING_TODO)
+ error_ret = ret;
+ }
+
+ if (error_ret) {
+ return error_ret;
+ }
+
+ return CMD_SUCCESS;
+}
+
+/* Configuration from terminal */
+DEFUN (config_terminal,
+ config_terminal_cmd,
+ "configure [terminal]",
+ "Configuration from vty interface\n"
+ "Configuration terminal\n")
+{
+ return vty_config_enter(vty, false, false);
+}
+
+/* Enable command */
+DEFUN (enable,
+ config_enable_cmd,
+ "enable",
+ "Turn on privileged mode command\n")
+{
+ /* If enable password is NULL, change to ENABLE_NODE */
+ if ((host.enable == NULL && host.enable_encrypt == NULL)
+ || vty->type == VTY_SHELL_SERV)
+ vty->node = ENABLE_NODE;
+ else
+ vty->node = AUTH_ENABLE_NODE;
+
+ return CMD_SUCCESS;
+}
+
+/* Disable command */
+DEFUN (disable,
+ config_disable_cmd,
+ "disable",
+ "Turn off privileged mode command\n")
+{
+ if (vty->node == ENABLE_NODE)
+ vty->node = VIEW_NODE;
+ return CMD_SUCCESS;
+}
+
+/* Down vty node level. */
+DEFUN (config_exit,
+ config_exit_cmd,
+ "exit",
+ "Exit current mode and down to previous mode\n")
+{
+ cmd_exit(vty);
+ return CMD_SUCCESS;
+}
+
+static int root_on_exit(struct vty *vty)
+{
+ if (vty_shell(vty))
+ exit(0);
+ else
+ vty->status = VTY_CLOSE;
+ return 0;
+}
+
+void cmd_exit(struct vty *vty)
+{
+ struct cmd_node *cnode = vector_lookup(cmdvec, vty->node);
+
+ if (cnode->node_exit) {
+ if (!cnode->node_exit(vty))
+ return;
+ }
+ if (cnode->parent_node)
+ vty->node = cnode->parent_node;
+ if (vty->xpath_index > 0 && !cnode->no_xpath)
+ vty->xpath_index--;
+}
+
+/* ALIAS_FIXME */
+DEFUN (config_quit,
+ config_quit_cmd,
+ "quit",
+ "Exit current mode and down to previous mode\n")
+{
+ return config_exit(self, vty, argc, argv);
+}
+
+
+/* End of configuration. */
+DEFUN (config_end,
+ config_end_cmd,
+ "end",
+ "End current mode and change to enable mode.\n")
+{
+ if (vty->config) {
+ vty_config_exit(vty);
+ vty->node = ENABLE_NODE;
+ }
+ return CMD_SUCCESS;
+}
+
+/* Show version. */
+DEFUN (show_version,
+ show_version_cmd,
+ "show version",
+ SHOW_STR
+ "Displays zebra version\n")
+{
+ vty_out(vty, "%s %s (%s) on %s(%s).\n", FRR_FULL_NAME, FRR_VERSION,
+ cmd_hostname_get() ? cmd_hostname_get() : "", cmd_system_get(),
+ cmd_release_get());
+ vty_out(vty, "%s%s\n", FRR_COPYRIGHT, GIT_INFO);
+#ifdef ENABLE_VERSION_BUILD_CONFIG
+ vty_out(vty, "configured with:\n %s\n", FRR_CONFIG_ARGS);
+#endif
+ return CMD_SUCCESS;
+}
+
+/* Help display function for all node. */
+DEFUN (config_help,
+ config_help_cmd,
+ "help",
+ "Description of the interactive help system\n")
+{
+ vty_out(vty,
+ "Quagga VTY provides advanced help feature. When you need help,\n\
+anytime at the command line please press '?'.\n\
+\n\
+If nothing matches, the help list will be empty and you must backup\n\
+ until entering a '?' shows the available options.\n\
+Two styles of help are provided:\n\
+1. Full help is available when you are ready to enter a\n\
+command argument (e.g. 'show ?') and describes each possible\n\
+argument.\n\
+2. Partial help is provided when an abbreviated argument is entered\n\
+ and you want to know what arguments match the input\n\
+ (e.g. 'show me?'.)\n\n");
+ return CMD_SUCCESS;
+}
+
+static void permute(struct graph_node *start, struct vty *vty)
+{
+ static struct list *position = NULL;
+ if (!position)
+ position = list_new();
+
+ struct cmd_token *stok = start->data;
+ struct graph_node *gnn;
+ struct listnode *ln;
+
+ // recursive dfs
+ listnode_add(position, start);
+ for (unsigned int i = 0; i < vector_active(start->to); i++) {
+ struct graph_node *gn = vector_slot(start->to, i);
+ struct cmd_token *tok = gn->data;
+ if (tok->attr == CMD_ATTR_HIDDEN
+ || tok->attr == CMD_ATTR_DEPRECATED)
+ continue;
+ else if (tok->type == END_TKN || gn == start) {
+ vty_out(vty, " ");
+ for (ALL_LIST_ELEMENTS_RO(position, ln, gnn)) {
+ struct cmd_token *tt = gnn->data;
+ if (tt->type < SPECIAL_TKN)
+ vty_out(vty, " %s", tt->text);
+ }
+ if (gn == start)
+ vty_out(vty, "...");
+ vty_out(vty, "\n");
+ } else {
+ bool skip = false;
+ if (stok->type == FORK_TKN && tok->type != FORK_TKN)
+ for (ALL_LIST_ELEMENTS_RO(position, ln, gnn))
+ if (gnn == gn) {
+ skip = true;
+ break;
+ }
+ if (!skip)
+ permute(gn, vty);
+ }
+ }
+ list_delete_node(position, listtail(position));
+}
+
+static void print_cmd(struct vty *vty, const char *cmd)
+{
+ int i, j, len = strlen(cmd);
+ char buf[len + 1];
+ bool skip = false;
+
+ j = 0;
+ for (i = 0; i < len; i++) {
+ /* skip varname */
+ if (cmd[i] == '$')
+ skip = true;
+ else if (strchr(" ()<>[]{}|", cmd[i]))
+ skip = false;
+
+ if (skip)
+ continue;
+
+ if (isspace(cmd[i])) {
+ /* skip leading whitespace */
+ if (i == 0)
+ continue;
+ /* skip trailing whitespace */
+ if (i == len - 1)
+ continue;
+ /* skip all whitespace after opening brackets or pipe */
+ if (strchr("(<[{|", cmd[i - 1])) {
+ while (isspace(cmd[i + 1]))
+ i++;
+ continue;
+ }
+ /* skip repeated whitespace */
+ if (isspace(cmd[i + 1]))
+ continue;
+ /* skip whitespace before closing brackets or pipe */
+ if (strchr(")>]}|", cmd[i + 1]))
+ continue;
+ /* convert tabs to spaces */
+ if (cmd[i] == '\t') {
+ buf[j++] = ' ';
+ continue;
+ }
+ }
+
+ buf[j++] = cmd[i];
+ }
+ buf[j] = 0;
+
+ vty_out(vty, "%s\n", buf);
+}
+
+int cmd_list_cmds(struct vty *vty, int do_permute)
+{
+ struct cmd_node *node = vector_slot(cmdvec, vty->node);
+
+ if (do_permute) {
+ cmd_finalize_node(node);
+ permute(vector_slot(node->cmdgraph->nodes, 0), vty);
+ } else {
+ /* loop over all commands at this node */
+ const struct cmd_element *element = NULL;
+ for (unsigned int i = 0; i < vector_active(node->cmd_vector);
+ i++)
+ if ((element = vector_slot(node->cmd_vector, i))
+ && element->attr != CMD_ATTR_DEPRECATED
+ && element->attr != CMD_ATTR_HIDDEN) {
+ vty_out(vty, " ");
+ print_cmd(vty, element->string);
+ }
+ }
+ return CMD_SUCCESS;
+}
+
+/* Help display function for all node. */
+DEFUN (config_list,
+ config_list_cmd,
+ "list [permutations]",
+ "Print command list\n"
+ "Print all possible command permutations\n")
+{
+ return cmd_list_cmds(vty, argc == 2);
+}
+
+DEFUN (show_commandtree,
+ show_commandtree_cmd,
+ "show commandtree [permutations]",
+ SHOW_STR
+ "Show command tree\n"
+ "Permutations that we are interested in\n")
+{
+ return cmd_list_cmds(vty, argc == 3);
+}
+
+DEFUN_HIDDEN(show_cli_graph,
+ show_cli_graph_cmd,
+ "show cli graph",
+ SHOW_STR
+ "CLI reflection\n"
+ "Dump current command space as DOT graph\n")
+{
+ struct cmd_node *cn = vector_slot(cmdvec, vty->node);
+ char *dot;
+
+ cmd_finalize_node(cn);
+ dot = cmd_graph_dump_dot(cn->cmdgraph);
+
+ vty_out(vty, "%s\n", dot);
+ XFREE(MTYPE_TMP, dot);
+ return CMD_SUCCESS;
+}
+
+static int vty_write_config(struct vty *vty)
+{
+ size_t i;
+ struct cmd_node *node;
+
+ if (host.noconfig)
+ return CMD_SUCCESS;
+
+ nb_cli_show_config_prepare(running_config, false);
+
+ if (vty->type == VTY_TERM) {
+ vty_out(vty, "\nCurrent configuration:\n");
+ vty_out(vty, "!\n");
+ }
+
+ if (strcmp(frr_defaults_version(), FRR_VER_SHORT))
+ vty_out(vty, "! loaded from %s\n", frr_defaults_version());
+ vty_out(vty, "frr version %s\n", FRR_VER_SHORT);
+ vty_out(vty, "frr defaults %s\n", frr_defaults_profile());
+ vty_out(vty, "!\n");
+
+ for (i = 0; i < vector_active(cmdvec); i++)
+ if ((node = vector_slot(cmdvec, i)) && node->config_write) {
+ if ((*node->config_write)(vty))
+ vty_out(vty, "!\n");
+ }
+
+ if (vty->type == VTY_TERM) {
+ vty_out(vty, "end\n");
+ }
+
+ return CMD_SUCCESS;
+}
+
+static int file_write_config(struct vty *vty)
+{
+ int fd, dirfd;
+ char *config_file, *slash;
+ char *config_file_tmp = NULL;
+ char *config_file_sav = NULL;
+ int ret = CMD_WARNING;
+ struct vty *file_vty;
+ struct stat conf_stat;
+
+ if (host.noconfig)
+ return CMD_SUCCESS;
+
+ /* Check and see if we are operating under vtysh configuration */
+ if (host.config == NULL) {
+ vty_out(vty,
+ "Can't save to configuration file, using vtysh.\n");
+ return CMD_WARNING;
+ }
+
+ /* Get filename. */
+ config_file = host.config;
+
+#ifndef O_DIRECTORY
+#define O_DIRECTORY 0
+#endif
+ slash = strrchr(config_file, '/');
+ if (slash) {
+ char *config_dir = XSTRDUP(MTYPE_TMP, config_file);
+ config_dir[slash - config_file] = '\0';
+ dirfd = open(config_dir, O_DIRECTORY | O_RDONLY);
+ XFREE(MTYPE_TMP, config_dir);
+ } else
+ dirfd = open(".", O_DIRECTORY | O_RDONLY);
+ /* if dirfd is invalid, directory sync fails, but we're still OK */
+
+ size_t config_file_sav_sz = strlen(config_file) + strlen(CONF_BACKUP_EXT) + 1;
+ config_file_sav = XMALLOC(MTYPE_TMP, config_file_sav_sz);
+ strlcpy(config_file_sav, config_file, config_file_sav_sz);
+ strlcat(config_file_sav, CONF_BACKUP_EXT, config_file_sav_sz);
+
+
+ config_file_tmp = XMALLOC(MTYPE_TMP, strlen(config_file) + 8);
+ snprintf(config_file_tmp, strlen(config_file) + 8, "%s.XXXXXX",
+ config_file);
+
+ /* Open file to configuration write. */
+ fd = mkstemp(config_file_tmp);
+ if (fd < 0) {
+ vty_out(vty, "Can't open configuration file %s.\n",
+ config_file_tmp);
+ goto finished;
+ }
+ if (fchmod(fd, CONFIGFILE_MASK) != 0) {
+ vty_out(vty, "Can't chmod configuration file %s: %s (%d).\n",
+ config_file_tmp, safe_strerror(errno), errno);
+ goto finished;
+ }
+
+ /* Make vty for configuration file. */
+ file_vty = vty_new();
+ file_vty->wfd = fd;
+ file_vty->type = VTY_FILE;
+
+ /* Config file header print. */
+ vty_out(file_vty, "!\n! Zebra configuration saved from vty\n! ");
+ vty_time_print(file_vty, 1);
+ vty_out(file_vty, "!\n");
+ vty_write_config(file_vty);
+ vty_close(file_vty);
+
+ if (stat(config_file, &conf_stat) >= 0) {
+ if (unlink(config_file_sav) != 0)
+ if (errno != ENOENT) {
+ vty_out(vty,
+ "Can't unlink backup configuration file %s.\n",
+ config_file_sav);
+ goto finished;
+ }
+ if (link(config_file, config_file_sav) != 0) {
+ vty_out(vty,
+ "Can't backup old configuration file %s.\n",
+ config_file_sav);
+ goto finished;
+ }
+ if (dirfd >= 0)
+ fsync(dirfd);
+ }
+ if (rename(config_file_tmp, config_file) != 0) {
+ vty_out(vty, "Can't save configuration file %s.\n",
+ config_file);
+ goto finished;
+ }
+ if (dirfd >= 0)
+ fsync(dirfd);
+
+ vty_out(vty, "Configuration saved to %s\n", config_file);
+ ret = CMD_SUCCESS;
+
+finished:
+ if (ret != CMD_SUCCESS)
+ unlink(config_file_tmp);
+ if (dirfd >= 0)
+ close(dirfd);
+ XFREE(MTYPE_TMP, config_file_tmp);
+ XFREE(MTYPE_TMP, config_file_sav);
+ return ret;
+}
+
+/* Write current configuration into file. */
+
+DEFUN (config_write,
+ config_write_cmd,
+ "write [<file|memory|terminal>]",
+ "Write running configuration to memory, network, or terminal\n"
+ "Write to configuration file\n"
+ "Write configuration currently in memory\n"
+ "Write configuration to terminal\n")
+{
+ const int idx_type = 1;
+
+ // if command was 'write terminal' or 'write memory'
+ if (argc == 2 && (!strcmp(argv[idx_type]->text, "terminal"))) {
+ return vty_write_config(vty);
+ }
+
+ return file_write_config(vty);
+}
+
+/* ALIAS_FIXME for 'write <terminal|memory>' */
+DEFUN (show_running_config,
+ show_running_config_cmd,
+ "show running-config",
+ SHOW_STR
+ "running configuration (same as write terminal)\n")
+{
+ return vty_write_config(vty);
+}
+
+/* ALIAS_FIXME for 'write file' */
+DEFUN (copy_runningconf_startupconf,
+ copy_runningconf_startupconf_cmd,
+ "copy running-config startup-config",
+ "Copy configuration\n"
+ "Copy running config to... \n"
+ "Copy running config to startup config (same as write file/memory)\n")
+{
+ return file_write_config(vty);
+}
+/** -- **/
+
+/* Write startup configuration into the terminal. */
+DEFUN (show_startup_config,
+ show_startup_config_cmd,
+ "show startup-config",
+ SHOW_STR
+ "Contents of startup configuration\n")
+{
+ char buf[BUFSIZ];
+ FILE *confp;
+
+ if (host.noconfig)
+ return CMD_SUCCESS;
+ if (host.config == NULL)
+ return CMD_WARNING;
+
+ confp = fopen(host.config, "r");
+ if (confp == NULL) {
+ vty_out(vty, "Can't open configuration file [%s] due to '%s'\n",
+ host.config, safe_strerror(errno));
+ return CMD_WARNING;
+ }
+
+ while (fgets(buf, BUFSIZ, confp)) {
+ char *cp = buf;
+
+ while (*cp != '\r' && *cp != '\n' && *cp != '\0')
+ cp++;
+ *cp = '\0';
+
+ vty_out(vty, "%s\n", buf);
+ }
+
+ fclose(confp);
+
+ return CMD_SUCCESS;
+}
+
+int cmd_domainname_set(const char *domainname)
+{
+ XFREE(MTYPE_HOST, host.domainname);
+ host.domainname = domainname ? XSTRDUP(MTYPE_HOST, domainname) : NULL;
+ return CMD_SUCCESS;
+}
+
+/* Hostname configuration */
+DEFUN(config_domainname,
+ domainname_cmd,
+ "domainname WORD",
+ "Set system's domain name\n"
+ "This system's domain name\n")
+{
+ struct cmd_token *word = argv[1];
+
+ if (!isalpha((unsigned char)word->arg[0])) {
+ vty_out(vty, "Please specify string starting with alphabet\n");
+ return CMD_WARNING_CONFIG_FAILED;
+ }
+
+ return cmd_domainname_set(word->arg);
+}
+
+DEFUN(config_no_domainname,
+ no_domainname_cmd,
+ "no domainname [DOMAINNAME]",
+ NO_STR
+ "Reset system's domain name\n"
+ "domain name of this router\n")
+{
+ return cmd_domainname_set(NULL);
+}
+
+int cmd_hostname_set(const char *hostname)
+{
+ XFREE(MTYPE_HOST, host.name);
+ host.name = hostname ? XSTRDUP(MTYPE_HOST, hostname) : NULL;
+ return CMD_SUCCESS;
+}
+
+/* Hostname configuration */
+DEFUN (config_hostname,
+ hostname_cmd,
+ "hostname WORD",
+ "Set system's network name\n"
+ "This system's network name\n")
+{
+ struct cmd_token *word = argv[1];
+
+ if (!isalnum((unsigned char)word->arg[0])) {
+ vty_out(vty,
+ "Please specify string starting with alphabet or number\n");
+ return CMD_WARNING_CONFIG_FAILED;
+ }
+
+ /* With reference to RFC 1123 Section 2.1 */
+ if (strlen(word->arg) > HOSTNAME_LEN) {
+ vty_out(vty, "Hostname length should be less than %d chars\n",
+ HOSTNAME_LEN);
+ return CMD_WARNING_CONFIG_FAILED;
+ }
+
+ return cmd_hostname_set(word->arg);
+}
+
+DEFUN (config_no_hostname,
+ no_hostname_cmd,
+ "no hostname [HOSTNAME]",
+ NO_STR
+ "Reset system's network name\n"
+ "Host name of this router\n")
+{
+ return cmd_hostname_set(NULL);
+}
+
+/* VTY interface password set. */
+DEFUN (config_password,
+ password_cmd,
+ "password [(8-8)] WORD",
+ "Modify the terminal connection password\n"
+ "Specifies a HIDDEN password will follow\n"
+ "The password string\n")
+{
+ int idx_8 = 1;
+ int idx_word = 2;
+ if (argc == 3) // '8' was specified
+ {
+ if (host.password)
+ XFREE(MTYPE_HOST, host.password);
+ host.password = NULL;
+ if (host.password_encrypt)
+ XFREE(MTYPE_HOST, host.password_encrypt);
+ host.password_encrypt =
+ XSTRDUP(MTYPE_HOST, argv[idx_word]->arg);
+ return CMD_SUCCESS;
+ }
+
+ if (!isalnum((unsigned char)argv[idx_8]->arg[0])) {
+ vty_out(vty,
+ "Please specify string starting with alphanumeric\n");
+ return CMD_WARNING_CONFIG_FAILED;
+ }
+
+ if (host.password)
+ XFREE(MTYPE_HOST, host.password);
+ host.password = NULL;
+
+ if (host.encrypt) {
+ if (host.password_encrypt)
+ XFREE(MTYPE_HOST, host.password_encrypt);
+ host.password_encrypt =
+ XSTRDUP(MTYPE_HOST, zencrypt(argv[idx_8]->arg));
+ } else
+ host.password = XSTRDUP(MTYPE_HOST, argv[idx_8]->arg);
+
+ return CMD_SUCCESS;
+}
+
+/* VTY interface password delete. */
+DEFUN (no_config_password,
+ no_password_cmd,
+ "no password",
+ NO_STR
+ "Modify the terminal connection password\n")
+{
+ bool warned = false;
+
+ if (host.password) {
+ if (!vty_shell_serv(vty)) {
+ vty_out(vty, NO_PASSWD_CMD_WARNING);
+ warned = true;
+ }
+ XFREE(MTYPE_HOST, host.password);
+ }
+ host.password = NULL;
+
+ if (host.password_encrypt) {
+ if (!warned && !vty_shell_serv(vty))
+ vty_out(vty, NO_PASSWD_CMD_WARNING);
+ XFREE(MTYPE_HOST, host.password_encrypt);
+ }
+ host.password_encrypt = NULL;
+
+ return CMD_SUCCESS;
+}
+
+/* VTY enable password set. */
+DEFUN (config_enable_password,
+ enable_password_cmd,
+ "enable password [(8-8)] WORD",
+ "Modify enable password parameters\n"
+ "Assign the privileged level password\n"
+ "Specifies a HIDDEN password will follow\n"
+ "The HIDDEN 'enable' password string\n")
+{
+ int idx_8 = 2;
+ int idx_word = 3;
+
+ /* Crypt type is specified. */
+ if (argc == 4) {
+ if (argv[idx_8]->arg[0] == '8') {
+ if (host.enable)
+ XFREE(MTYPE_HOST, host.enable);
+ host.enable = NULL;
+
+ if (host.enable_encrypt)
+ XFREE(MTYPE_HOST, host.enable_encrypt);
+ host.enable_encrypt =
+ XSTRDUP(MTYPE_HOST, argv[idx_word]->arg);
+
+ return CMD_SUCCESS;
+ } else {
+ vty_out(vty, "Unknown encryption type.\n");
+ return CMD_WARNING_CONFIG_FAILED;
+ }
+ }
+
+ if (!isalnum((unsigned char)argv[idx_8]->arg[0])) {
+ vty_out(vty,
+ "Please specify string starting with alphanumeric\n");
+ return CMD_WARNING_CONFIG_FAILED;
+ }
+
+ if (host.enable)
+ XFREE(MTYPE_HOST, host.enable);
+ host.enable = NULL;
+
+ /* Plain password input. */
+ if (host.encrypt) {
+ if (host.enable_encrypt)
+ XFREE(MTYPE_HOST, host.enable_encrypt);
+ host.enable_encrypt =
+ XSTRDUP(MTYPE_HOST, zencrypt(argv[idx_8]->arg));
+ } else
+ host.enable = XSTRDUP(MTYPE_HOST, argv[idx_8]->arg);
+
+ return CMD_SUCCESS;
+}
+
+/* VTY enable password delete. */
+DEFUN (no_config_enable_password,
+ no_enable_password_cmd,
+ "no enable password",
+ NO_STR
+ "Modify enable password parameters\n"
+ "Assign the privileged level password\n")
+{
+ bool warned = false;
+
+ if (host.enable) {
+ if (!vty_shell_serv(vty)) {
+ vty_out(vty, NO_PASSWD_CMD_WARNING);
+ warned = true;
+ }
+ XFREE(MTYPE_HOST, host.enable);
+ }
+ host.enable = NULL;
+
+ if (host.enable_encrypt) {
+ if (!warned && !vty_shell_serv(vty))
+ vty_out(vty, NO_PASSWD_CMD_WARNING);
+ XFREE(MTYPE_HOST, host.enable_encrypt);
+ }
+ host.enable_encrypt = NULL;
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (service_password_encrypt,
+ service_password_encrypt_cmd,
+ "service password-encryption",
+ "Set up miscellaneous service\n"
+ "Enable encrypted passwords\n")
+{
+ if (host.encrypt)
+ return CMD_SUCCESS;
+
+ host.encrypt = 1;
+
+ if (host.password) {
+ if (host.password_encrypt)
+ XFREE(MTYPE_HOST, host.password_encrypt);
+ host.password_encrypt =
+ XSTRDUP(MTYPE_HOST, zencrypt(host.password));
+ }
+ if (host.enable) {
+ if (host.enable_encrypt)
+ XFREE(MTYPE_HOST, host.enable_encrypt);
+ host.enable_encrypt =
+ XSTRDUP(MTYPE_HOST, zencrypt(host.enable));
+ }
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (no_service_password_encrypt,
+ no_service_password_encrypt_cmd,
+ "no service password-encryption",
+ NO_STR
+ "Set up miscellaneous service\n"
+ "Enable encrypted passwords\n")
+{
+ if (!host.encrypt)
+ return CMD_SUCCESS;
+
+ host.encrypt = 0;
+
+ if (host.password_encrypt)
+ XFREE(MTYPE_HOST, host.password_encrypt);
+ host.password_encrypt = NULL;
+
+ if (host.enable_encrypt)
+ XFREE(MTYPE_HOST, host.enable_encrypt);
+ host.enable_encrypt = NULL;
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (config_terminal_length,
+ config_terminal_length_cmd,
+ "terminal length (0-512)",
+ "Set terminal line parameters\n"
+ "Set number of lines on a screen\n"
+ "Number of lines on screen (0 for no pausing)\n")
+{
+ int idx_number = 2;
+
+ vty->lines = atoi(argv[idx_number]->arg);
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (config_terminal_no_length,
+ config_terminal_no_length_cmd,
+ "terminal no length",
+ "Set terminal line parameters\n"
+ NO_STR
+ "Set number of lines on a screen\n")
+{
+ vty->lines = -1;
+ return CMD_SUCCESS;
+}
+
+DEFUN (service_terminal_length,
+ service_terminal_length_cmd,
+ "service terminal-length (0-512)",
+ "Set up miscellaneous service\n"
+ "System wide terminal length configuration\n"
+ "Number of lines of VTY (0 means no line control)\n")
+{
+ int idx_number = 2;
+
+ host.lines = atoi(argv[idx_number]->arg);
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (no_service_terminal_length,
+ no_service_terminal_length_cmd,
+ "no service terminal-length [(0-512)]",
+ NO_STR
+ "Set up miscellaneous service\n"
+ "System wide terminal length configuration\n"
+ "Number of lines of VTY (0 means no line control)\n")
+{
+ host.lines = -1;
+ return CMD_SUCCESS;
+}
+
+DEFUN_HIDDEN (do_echo,
+ echo_cmd,
+ "echo MESSAGE...",
+ "Echo a message back to the vty\n"
+ "The message to echo\n")
+{
+ char *message;
+
+ vty_out(vty, "%s\n",
+ ((message = argv_concat(argv, argc, 1)) ? message : ""));
+ if (message)
+ XFREE(MTYPE_TMP, message);
+ return CMD_SUCCESS;
+}
+
+DEFUN (config_logmsg,
+ config_logmsg_cmd,
+ "logmsg <emergencies|alerts|critical|errors|warnings|notifications|informational|debugging> MESSAGE...",
+ "Send a message to enabled logging destinations\n"
+ LOG_LEVEL_DESC
+ "The message to send\n")
+{
+ int idx_log_level = 1;
+ int idx_message = 2;
+ int level;
+ char *message;
+
+ level = log_level_match(argv[idx_log_level]->arg);
+ if (level == ZLOG_DISABLED)
+ return CMD_ERR_NO_MATCH;
+
+ zlog(level, "%s",
+ ((message = argv_concat(argv, argc, idx_message)) ? message : ""));
+ if (message)
+ XFREE(MTYPE_TMP, message);
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (debug_memstats,
+ debug_memstats_cmd,
+ "[no] debug memstats-at-exit",
+ NO_STR
+ DEBUG_STR
+ "Print memory type statistics at exit\n")
+{
+ debug_memstats_at_exit = !!strcmp(argv[0]->text, "no");
+ return CMD_SUCCESS;
+}
+
+int cmd_banner_motd_file(const char *file)
+{
+ int success = CMD_SUCCESS;
+ char p[PATH_MAX];
+ char *rpath;
+ char *in;
+
+ rpath = realpath(file, p);
+ if (!rpath)
+ return CMD_ERR_NO_FILE;
+ in = strstr(rpath, SYSCONFDIR);
+ if (in == rpath) {
+ XFREE(MTYPE_HOST, host.motdfile);
+ host.motdfile = XSTRDUP(MTYPE_HOST, file);
+ } else
+ success = CMD_WARNING_CONFIG_FAILED;
+
+ return success;
+}
+
+void cmd_banner_motd_line(const char *line)
+{
+ XFREE(MTYPE_HOST, host.motd);
+ host.motd = XSTRDUP(MTYPE_HOST, line);
+}
+
+DEFUN (banner_motd_file,
+ banner_motd_file_cmd,
+ "banner motd file FILE",
+ "Set banner\n"
+ "Banner for motd\n"
+ "Banner from a file\n"
+ "Filename\n")
+{
+ int idx_file = 3;
+ const char *filename = argv[idx_file]->arg;
+ int cmd = cmd_banner_motd_file(filename);
+
+ if (cmd == CMD_ERR_NO_FILE)
+ vty_out(vty, "%s does not exist\n", filename);
+ else if (cmd == CMD_WARNING_CONFIG_FAILED)
+ vty_out(vty, "%s must be in %s\n", filename, SYSCONFDIR);
+
+ return cmd;
+}
+
+DEFUN (banner_motd_line,
+ banner_motd_line_cmd,
+ "banner motd line LINE...",
+ "Set banner\n"
+ "Banner for motd\n"
+ "Banner from an input\n"
+ "Text\n")
+{
+ int idx = 0;
+ char *motd;
+
+ argv_find(argv, argc, "LINE", &idx);
+ motd = argv_concat(argv, argc, idx);
+
+ cmd_banner_motd_line(motd);
+ XFREE(MTYPE_TMP, motd);
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (banner_motd_default,
+ banner_motd_default_cmd,
+ "banner motd default",
+ "Set banner string\n"
+ "Strings for motd\n"
+ "Default string\n")
+{
+ cmd_banner_motd_line(FRR_DEFAULT_MOTD);
+ return CMD_SUCCESS;
+}
+
+DEFUN (no_banner_motd,
+ no_banner_motd_cmd,
+ "no banner motd",
+ NO_STR
+ "Set banner string\n"
+ "Strings for motd\n")
+{
+ host.motd = NULL;
+ if (host.motdfile)
+ XFREE(MTYPE_HOST, host.motdfile);
+ host.motdfile = NULL;
+ return CMD_SUCCESS;
+}
+
+DEFUN(allow_reserved_ranges, allow_reserved_ranges_cmd, "allow-reserved-ranges",
+ "Allow using IPv4 (Class E) reserved IP space\n")
+{
+ host.allow_reserved_ranges = true;
+ return CMD_SUCCESS;
+}
+
+DEFUN(no_allow_reserved_ranges, no_allow_reserved_ranges_cmd,
+ "no allow-reserved-ranges",
+ NO_STR "Allow using IPv4 (Class E) reserved IP space\n")
+{
+ host.allow_reserved_ranges = false;
+ return CMD_SUCCESS;
+}
+
+int cmd_find_cmds(struct vty *vty, struct cmd_token **argv, int argc)
+{
+ const struct cmd_node *node;
+ const struct cmd_element *cli;
+ vector clis;
+
+ regex_t exp = {};
+
+ char *pattern = argv_concat(argv, argc, 1);
+ int cr = regcomp(&exp, pattern, REG_NOSUB | REG_EXTENDED);
+ XFREE(MTYPE_TMP, pattern);
+
+ if (cr != 0) {
+ switch (cr) {
+ case REG_BADBR:
+ vty_out(vty, "%% Invalid {...} expression\n");
+ break;
+ case REG_BADRPT:
+ vty_out(vty, "%% Bad repetition operator\n");
+ break;
+ case REG_BADPAT:
+ vty_out(vty, "%% Regex syntax error\n");
+ break;
+ case REG_ECOLLATE:
+ vty_out(vty, "%% Invalid collating element\n");
+ break;
+ case REG_ECTYPE:
+ vty_out(vty, "%% Invalid character class name\n");
+ break;
+ case REG_EESCAPE:
+ vty_out(vty,
+ "%% Regex ended with escape character (\\)\n");
+ break;
+ case REG_ESUBREG:
+ vty_out(vty,
+ "%% Invalid number in \\digit construction\n");
+ break;
+ case REG_EBRACK:
+ vty_out(vty, "%% Unbalanced square brackets\n");
+ break;
+ case REG_EPAREN:
+ vty_out(vty, "%% Unbalanced parentheses\n");
+ break;
+ case REG_EBRACE:
+ vty_out(vty, "%% Unbalanced braces\n");
+ break;
+ case REG_ERANGE:
+ vty_out(vty,
+ "%% Invalid endpoint in range expression\n");
+ break;
+ case REG_ESPACE:
+ vty_out(vty, "%% Failed to compile (out of memory)\n");
+ break;
+ }
+
+ goto done;
+ }
+
+
+ for (unsigned int i = 0; i < vector_active(cmdvec); i++) {
+ node = vector_slot(cmdvec, i);
+ if (!node)
+ continue;
+ clis = node->cmd_vector;
+ for (unsigned int j = 0; j < vector_active(clis); j++) {
+ cli = vector_slot(clis, j);
+
+ if (regexec(&exp, cli->string, 0, NULL, 0) == 0) {
+ vty_out(vty, " (%s) ", node->name);
+ print_cmd(vty, cli->string);
+ }
+ }
+ }
+
+done:
+ regfree(&exp);
+ return CMD_SUCCESS;
+}
+
+DEFUN(find,
+ find_cmd,
+ "find REGEX...",
+ "Find CLI command matching a regular expression\n"
+ "Search pattern (POSIX regex)\n")
+{
+ return cmd_find_cmds(vty, argv, argc);
+}
+
+#if defined(DEV_BUILD) && defined(HAVE_SCRIPTING)
+DEFUN(script, script_cmd, "script SCRIPT FUNCTION",
+ "Test command - execute a function in a script\n"
+ "Script name (same as filename in /etc/frr/scripts/)\n"
+ "Function name (in the script)\n")
+{
+ struct prefix p;
+
+ (void)str2prefix("1.2.3.4/24", &p);
+ struct frrscript *fs = frrscript_new(argv[1]->arg);
+
+ if (frrscript_load(fs, argv[2]->arg, NULL)) {
+ vty_out(vty,
+ "/etc/frr/scripts/%s.lua or function '%s' not found\n",
+ argv[1]->arg, argv[2]->arg);
+ }
+
+ int ret = frrscript_call(fs, argv[2]->arg, ("p", &p));
+ char buf[40];
+ prefix2str(&p, buf, sizeof(buf));
+ vty_out(vty, "p: %s\n", buf);
+ vty_out(vty, "Script result: %d\n", ret);
+
+ frrscript_delete(fs);
+
+ return CMD_SUCCESS;
+}
+#endif
+
+/* Set config filename. Called from vty.c */
+void host_config_set(const char *filename)
+{
+ XFREE(MTYPE_HOST, host.config);
+ host.config = XSTRDUP(MTYPE_HOST, filename);
+}
+
+const char *host_config_get(void)
+{
+ return host.config;
+}
+
+void install_default(enum node_type node)
+{
+ _install_element(node, &config_exit_cmd);
+ _install_element(node, &config_quit_cmd);
+ _install_element(node, &config_end_cmd);
+ _install_element(node, &config_help_cmd);
+ _install_element(node, &config_list_cmd);
+ _install_element(node, &show_cli_graph_cmd);
+ _install_element(node, &find_cmd);
+
+ _install_element(node, &config_write_cmd);
+ _install_element(node, &show_running_config_cmd);
+
+ _install_element(node, &autocomplete_cmd);
+
+ nb_cli_install_default(node);
+}
+
+/* Initialize command interface. Install basic nodes and commands.
+ *
+ * terminal = 0 -- vtysh / no logging, no config control
+ * terminal = 1 -- normal daemon
+ * terminal = -1 -- watchfrr / no logging, but minimal config control */
+void cmd_init(int terminal)
+{
+ struct utsname names;
+
+ uname(&names);
+ qobj_init();
+
+ /* register command preprocessors */
+ hook_register(cmd_execute, handle_pipe_action);
+ hook_register(cmd_execute_done, handle_pipe_action_done);
+
+ varhandlers = list_new();
+
+ /* Allocate initial top vector of commands. */
+ cmdvec = vector_init(VECTOR_MIN_SIZE);
+
+ /* Default host value settings. */
+ host.name = XSTRDUP(MTYPE_HOST, names.nodename);
+ host.system = XSTRDUP(MTYPE_HOST, names.sysname);
+ host.release = XSTRDUP(MTYPE_HOST, names.release);
+ host.version = XSTRDUP(MTYPE_HOST, names.version);
+
+#ifdef HAVE_STRUCT_UTSNAME_DOMAINNAME
+ if ((strcmp(names.domainname, "(none)") == 0))
+ host.domainname = NULL;
+ else
+ host.domainname = XSTRDUP(MTYPE_HOST, names.domainname);
+#else
+ host.domainname = NULL;
+#endif
+ host.password = NULL;
+ host.enable = NULL;
+ host.config = NULL;
+ host.noconfig = (terminal < 0);
+ host.lines = -1;
+ cmd_banner_motd_line(FRR_DEFAULT_MOTD);
+ host.motdfile = NULL;
+ host.allow_reserved_ranges = false;
+
+ /* Install top nodes. */
+ install_node(&view_node);
+ install_node(&enable_node);
+ install_node(&auth_node);
+ install_node(&auth_enable_node);
+ install_node(&config_node);
+
+ /* Each node's basic commands. */
+ install_element(VIEW_NODE, &show_version_cmd);
+ install_element(ENABLE_NODE, &show_startup_config_cmd);
+
+ if (terminal) {
+ install_element(ENABLE_NODE, &debug_memstats_cmd);
+
+ install_element(VIEW_NODE, &config_list_cmd);
+ install_element(VIEW_NODE, &config_exit_cmd);
+ install_element(VIEW_NODE, &config_quit_cmd);
+ install_element(VIEW_NODE, &config_help_cmd);
+ install_element(VIEW_NODE, &config_enable_cmd);
+ install_element(VIEW_NODE, &config_terminal_length_cmd);
+ install_element(VIEW_NODE, &config_terminal_no_length_cmd);
+ install_element(VIEW_NODE, &show_commandtree_cmd);
+ install_element(VIEW_NODE, &echo_cmd);
+ install_element(VIEW_NODE, &autocomplete_cmd);
+ install_element(VIEW_NODE, &find_cmd);
+#if defined(DEV_BUILD) && defined(HAVE_SCRIPTING)
+ install_element(VIEW_NODE, &script_cmd);
+#endif
+
+
+ install_element(ENABLE_NODE, &config_end_cmd);
+ install_element(ENABLE_NODE, &config_disable_cmd);
+ install_element(ENABLE_NODE, &config_terminal_cmd);
+ install_element(ENABLE_NODE, &copy_runningconf_startupconf_cmd);
+ install_element(ENABLE_NODE, &config_write_cmd);
+ install_element(ENABLE_NODE, &show_running_config_cmd);
+ install_element(ENABLE_NODE, &config_logmsg_cmd);
+
+ install_default(CONFIG_NODE);
+
+ thread_cmd_init();
+ workqueue_cmd_init();
+ hash_cmd_init();
+ }
+
+ install_element(CONFIG_NODE, &hostname_cmd);
+ install_element(CONFIG_NODE, &no_hostname_cmd);
+ install_element(CONFIG_NODE, &domainname_cmd);
+ install_element(CONFIG_NODE, &no_domainname_cmd);
+
+ if (terminal > 0) {
+ full_cli = true;
+
+ install_element(CONFIG_NODE, &debug_memstats_cmd);
+
+ install_element(CONFIG_NODE, &password_cmd);
+ install_element(CONFIG_NODE, &no_password_cmd);
+ install_element(CONFIG_NODE, &enable_password_cmd);
+ install_element(CONFIG_NODE, &no_enable_password_cmd);
+
+ install_element(CONFIG_NODE, &service_password_encrypt_cmd);
+ install_element(CONFIG_NODE, &no_service_password_encrypt_cmd);
+ install_element(CONFIG_NODE, &banner_motd_default_cmd);
+ install_element(CONFIG_NODE, &banner_motd_file_cmd);
+ install_element(CONFIG_NODE, &banner_motd_line_cmd);
+ install_element(CONFIG_NODE, &no_banner_motd_cmd);
+ install_element(CONFIG_NODE, &service_terminal_length_cmd);
+ install_element(CONFIG_NODE, &no_service_terminal_length_cmd);
+ install_element(CONFIG_NODE, &allow_reserved_ranges_cmd);
+ install_element(CONFIG_NODE, &no_allow_reserved_ranges_cmd);
+
+ log_cmd_init();
+ vrf_install_commands();
+ }
+
+#ifdef DEV_BUILD
+ grammar_sandbox_init();
+#endif
+}
+
+void cmd_terminate(void)
+{
+ struct cmd_node *cmd_node;
+
+ hook_unregister(cmd_execute, handle_pipe_action);
+ hook_unregister(cmd_execute_done, handle_pipe_action_done);
+
+ if (cmdvec) {
+ for (unsigned int i = 0; i < vector_active(cmdvec); i++)
+ if ((cmd_node = vector_slot(cmdvec, i)) != NULL) {
+ // deleting the graph delets the cmd_element as
+ // well
+ graph_delete_graph(cmd_node->cmdgraph);
+ vector_free(cmd_node->cmd_vector);
+ hash_clean(cmd_node->cmd_hash, NULL);
+ hash_free(cmd_node->cmd_hash);
+ cmd_node->cmd_hash = NULL;
+ }
+
+ vector_free(cmdvec);
+ cmdvec = NULL;
+ }
+
+ XFREE(MTYPE_HOST, host.name);
+ XFREE(MTYPE_HOST, host.system);
+ XFREE(MTYPE_HOST, host.release);
+ XFREE(MTYPE_HOST, host.version);
+ XFREE(MTYPE_HOST, host.domainname);
+ XFREE(MTYPE_HOST, host.password);
+ XFREE(MTYPE_HOST, host.password_encrypt);
+ XFREE(MTYPE_HOST, host.enable);
+ XFREE(MTYPE_HOST, host.enable_encrypt);
+ XFREE(MTYPE_HOST, host.motdfile);
+ XFREE(MTYPE_HOST, host.config);
+ XFREE(MTYPE_HOST, host.motd);
+
+ list_delete(&varhandlers);
+ qobj_finish();
+}