Merge pull request #9846 from idryzhov/lib-zebra-netns

[mirror_frr.git] / lib / command.c

/*
 * 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;
}

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,
};

static bool vty_check_node_for_xpath_decrement(enum node_type target_node,
                                               enum node_type node)
{
        /* bgp afi-safi (`address-family <afi> <safi>`) node
         * does not increment xpath_index.
         * In order to use (`router bgp`) BGP_NODE's xpath as a base,
         * retain xpath_index as 1 upon exiting from
         * afi-safi node.
         */

        if (target_node == BGP_NODE
            && (node == BGP_IPV4_NODE || node == BGP_IPV6_NODE
                || node == BGP_IPV4M_NODE || node == BGP_IPV6M_NODE
                || node == BGP_VPNV4_NODE || node == BGP_VPNV6_NODE
                || node == BGP_EVPN_NODE || node == BGP_IPV4L_NODE
                || node == BGP_IPV6L_NODE || node == BGP_FLOWSPECV4_NODE
                || node == BGP_FLOWSPECV6_NODE))
                return false;

        if (target_node == INTERFACE_NODE && node == LINK_PARAMS_NODE)
                return false;

        return true;
}

/* 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;
        }

        assert(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;
        char *crypt(const char *, const char *);

        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)
{
        if (cmd_hostname_get())
                vty_out(vty, "hostname %s\n", cmd_hostname_get());

        if (cmd_domainname_get())
                vty_out(vty, "domainname %s\n", cmd_domainname_get());

        /* 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);

                if (cs + itemlen + AUTOCOMP_INDENT + 3 >= bsz)
                        buf = XREALLOC(MTYPE_TMP, buf, (bsz *= 2));

                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++) {
                if (node <= CONFIG_NODE)
                        return CMD_NO_LEVEL_UP;

                node = node_parent(node);

                if (xpath_index > 0
                    && vty_check_node_for_xpath_decrement(node, vty->node))
                        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) {
                        try_node = node_parent(try_node);
                        vty->node = try_node;
                        if (vty->xpath_index > 0
                            && vty_check_node_for_xpath_decrement(try_node,
                                                                  onode))
                                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
            && vty_check_node_for_xpath_decrement(vty->node, cnode->node))
                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).\n", FRR_FULL_NAME, FRR_VERSION,
                cmd_hostname_get() ? cmd_hostname_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", filename);
        else if (cmd == CMD_WARNING_CONFIG_FAILED)
                vty_out(vty, "%s must be in %s", 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;
}

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);
#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;

        /* 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);

                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.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();
}